// 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 : 10/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 le clavier
// Utilise la librairie GSVideo de capture et lecture vidéo
// Utilise la librairie OpenCV de capture vidéo et reconnaissance visuelle

// XXXXXXXXXXXXXXXXXXXXXX ENTETE DECLARATIVE XXXXXXXXXXXXXXXXXXXXXX

// inclusion des librairies utilisées

// — pour le contrôle de la souris par le programme – utilise la classe Robot Java
import java.awt.AWTException;
import java.awt.Robot;
import java.awt.event.InputEvent;

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 hypermedia.video.*; // importe la librairie OpenCV qui implémente la capture vidéo et la reconnaissance visuelle pour Processing
// cette librairie doit être présente dans le répertoire modes/java/libraries du répertoire Processing (1-5)
// voir ici : http://ubaa.net/shared/processing/opencv/

// déclaration objets

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

PImage imgCapture;
PImage imgSource, imgDest;

String cheminFichierImage=« /home/hinault/Bureau/trans/ »;
String nomFichierImage=« monimage.png »;

String cheminFichierSon=« /home/hinault/Bureau/mes_sons/bruitages/ »;
String nomFichierSon=« camera-click-1.wav »;

// Robot robot; // crée une instance de la classe Robot pour le contrôle de la souris

// 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=15; // framerate (image/secondes) pour la capture video

int detectX, detectY; // détection de doigt
int detectXClicG, detectYClicG; // détection de doigt pour clic Gauche
int detectXClicD, detectYClicD; // détection de doigt pour clic Gauche

boolean stateClicD=false;
boolean stateClicG=false;

int cumulX=0, cumulY=0;
int moyX=0, moyY=0;
int nbMoy=2, comptMoy=0;

//— valeur à fixer empiriquement —
float ecartG=75.0; // ecart entre point central (index) et pouce ouvert
float ecartD=110.0; // ecart entre point central (index) et auriculaire ouvert
float echelle=0.7; // echelle taille main

// XXXXXXXXXXXXXXXXXXXXXX  Fonction SETUP XXXXXXXXXXXXXXXXXXXXXX

void setup(){ // fonction d’initialisation exécutée 1 fois au démarrage

        // —- initialisation paramètres graphiques utilisés
        //colorMode(HSB, 360,200,200); // fixe format couleur R G B pour fill, stroke, etc…
        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(20);// Images par seconde – The default rate is 60 frames per second

        // — initialisation fenêtre de base —
        size(widthCapture*3, heightCapture); // 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
        // 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 (vidéo et reconnaissance visuelle =========

        opencv = new OpenCV(this); // initialise objet OpenCV à partir du parent This
        opencv.allocate(widthCapture,heightCapture); // crée le buffer image de la taille voulue
        // la capture de flux multiples n’est pas possible avec openCV.
        // Ici, on utilise GSVideo pour capturer le flux video et OpenCV pour l’analyse d’image seulement
        // Au final, on abouti à une amélioration significative de la rapidité d’exécution

//—- initialisation contrôle de la souris par objet Robot —
/*
      try {
        robot = new Robot();
      }
      catch (AWTException e) {
        e.printStackTrace();
      }

      robot.mouseMove(screenWidth/2, screenHeight/2); // positionement initial à la position courante de la souris

*/

} // 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
    imgSource=cam1.get();

    imgDest=rotateImage(imgSource);  // rotation 180° image source

    image(imgDest, 0, 0); // affiche image
    //set(0, 0, cam); // affiche image – plus rapide

    //imgDest=monochromeCanal(imgSource, »Red »);
    //imgDest=monochromeCanalR(imgSource);

    imgDest=filtreSobel(imgDest); // détection contour par Sobel

    imgDest.filter(THRESHOLD, 0.90);// seuillage

    /* — Infos filter —

    THRESHOLD – converts the image to black and white pixels depending if they are above or below the threshold defined by the level parameter. The level must be between 0.0 (black) and 1.0(white). If no level is specified, 0.5 is used.

    GRAY – converts any colors in the image to grayscale equivalents

    INVERT – sets each pixel to its inverse value

    POSTERIZE – limits each channel of the image to the number of colors specified as the level parameter

    BLUR – executes a Guassian blur with the level parameter specifying the extent of the blurring. If no level parameter is used, the blur is equivalent to Guassian blur of radius 1.

    OPAQUE – sets the alpha channel to entirely opaque.

    ERODE – reduces the light areas with the amount defined by the level parameter.

    DILATE – increases the light areas with the amount defined by the level parameter.
    */

    //imgDest=traitementImage(imgSource);
    imgCapture=imgDest.get();
    image(imgDest, widthCapture, 0); // affiche image

    detectionPointUtile(imgDest); // détecte point utile – les variables detectX et detectY sont mises à jours

/*    
    //robot.mouseMove(int(map (detectX,0,widthCapture,0,screenWidth)), int(map (detectY,0,heightCapture,0,screenHeight)));
    robot.mouseMove(int(map (moyX-(widthCapture/2),0,widthCapture/4,0,screenWidth)), int(map (moyY-(heightCapture/2),0,heightCapture/4,0,screenHeight)));
    // le coin sup gauche du « touchpad » est fixé par moyX-val et moyY-val
    // la largeur/hauteur du touchpad est fixée par widthCapture/3 et heigth/3

      if ((moyX-detectXClicG> 100) && (stateClicG==false)) { // si position clic G et pas de clic Gauche actif

        // Simulate a mouse click
        robot.mousePress(InputEvent.BUTTON1_MASK); // enfonce bouton Gauche souris
        robot.mouseRelease(InputEvent.BUTTON1_MASK);

        stateClicG=true; // mémorise bouton G appuyé
        delay(250);

        }
        else if ((moyX-detectXClicG< 100) && (stateClicG==true)) {

        robot.mouseRelease(InputEvent.BUTTON1_MASK);
        stateClicG=false; // mémorise bouton G pas appuyé

        }
 */

  } // fin if available

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

} // fin de la fonction draw()

// XXXXXXXXXXXXXXXXXXXXXX Autres Fonctions XXXXXXXXXXXXXXXXXXXXXX

//—- fonction de détection du point le plus « bas » d’une image —
// modifie les variables detectX et detectY

void detectionPointUtile(PImage imgIn) {

  //int maxX=0;
  //int maxY=0;
  detectX=0;
  detectY=heightCapture;

  int bord=10; // zone du bord pas prise en compte pour analyse – évite artéfact

  detectXClicD=0; // le bord gauche
  detectYClicD=heightCapture;

  detectXClicG=widthCapture; // le bord droit
  detectYClicG=heightCapture;

  imgIn.loadPixels(); // charge les pixels de l’image en mémoire

  for(int x = bord; x <  (imgIn.width–bord); x=x+1) { // —- défilement des x de l’image à traiter

      for(int y = bord; y <  (imgIn.height–bord); y=y+1) {// —- défilement des y de l’image à traiter

            float R = red(imgIn.pixels[ x + (y *  imgIn.width) ]);// la couleur rouge
            float G = green(imgIn.pixels[ x + (y *  imgIn.width) ]); // la couleur verte            
            float B = blue(imgIn.pixels[ x + (y *  imgIn.width) ]); // la couleur bleue

            float H = hue(imgIn.pixels[ x + (y *  imgIn.width) ]);// la teinte (hue)
            float S = saturation(imgIn.pixels[ x + (y *  imgIn.width) ]); // la saturation
            float V = brightness(imgIn.pixels[ x + (y *  imgIn.width) ]); // la brillance ou « valeur »

            imgIn.pixels[ x + (y *  imgIn.width)] = color(bleu); // modifie le pixel en fonction  = image niveau de gris basée sur canal rouge

            if (R>250) { // si le point est blanc

              // analyse pour point le plus haut dans l’image
              if (y<detectY) { // prend en compte le y courant si est inférieur au dernier pris en compte

                  detectY=y; // prend en compte le y courant si est inférieur au dernier pris en compte

                // au final le y vaudra le plus bas de tous les pixels

                detectX=x; // prend en compte x associé

              } // fin if max

              // analyse du point pouce —

              if (x<detectXClicG) { // prend en compte le x courant si est inférieur au dernier pris en compte

                  detectXClicG=x; // prend en compte le x courant si est inférieur au dernier pris en compte
                // au final le x vaudra le plus bas de tous les pixels

                detectYClicG=y; // prend en compte x associé

              } // fin if detectXClicG

              // analyse du point index —

              if (x>detectXClicD) { // prend en compte le x courant si est inférieur au dernier pris en compte

                  detectXClicD=x; // prend en compte le x courant si est inférieur au dernier pris en compte
                // au final le x vaudra le plus bas de tous les pixels

                detectYClicD=y; // prend en compte x associé

              } // fin if detectXClicG

            } // fin if R==255

      } // fin for y      

    } // fin for x

        cumulX=cumulX+detectX;
        cumulY=cumulY+detectY;
        comptMoy=comptMoy+1; // incrémente comptMoy

        if (comptMoy==nbMoy) { // une fois que n valeurs prises en compte

          moyX=cumulX/nbMoy; // calcule moyenne X
          moyY=cumulY/nbMoy; // calcule moyenne Y

          // RAZ
          comptMoy=0; // RAZ comptMoy
          cumulX=0;
          cumulY=0;

        } // fin comptMoy == nbMoy

        fill(bleu);
        ellipse (moyX,moyY, 10,10);

        if (moyX–detectXClicG> (ecartG*echelle)) {
          fill(jaune);
          println(« Pouce ouvert ! »);
        }
        else fill(bleu);

        ellipse (detectXClicG,detectYClicG, 10,10);

        if (detectXClicD–moyX> (ecartD*echelle)) {
          fill(jaune);
          println(« Auriculaire ouvert ! »);
        }
          else fill(bleu);
        ellipse (detectXClicD,detectYClicD, 10,10);

        //imgIn.updatePixels();  // met à jour les pixels de l’image  

        //return (imgIn); // renvoi image modifiée

} // fin fonction detection point

//xxxxxxxxxxxxxxxxxxxx fonction filtre SOBEL (détection contours) xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
// www.mon-club-elec.fr – Par X.HINAULT – Tous droits réservés – Mai 2011 – Licence GPL
// dérivé de : sobel edge from http://www.openprocessing.org

PImage filtreSobel (PImage imgIn) { //————- début fonction filtre sobel ——————-

    PImage imgSobel; // image qui sera renvoyée par la fonction

    imgSobel=imgIn.get(); // crée une image à partir image reçue par la fonction

    imgSobel.loadPixels(); // charge les pixels de l’image en mémoire

    //————- définition du masque x – matrice 3 x 3 ————-  
    //  -1  0  1  
    //  -2  0  2
    //  -1  0  1

    int GX[][] = new int[3][3];

    // 3×3 Sobel Mask for X
    GX[0][0] = –1;
    GX[0][1] = 0;
    GX[0][2] = 1;
    GX[1][0] = –2;
    GX[1][1] = 0;
    GX[1][2] = 2;
    GX[2][0] = –1;
    GX[2][1] = 0;
    GX[2][2] = 1;

    //—————— définition du masque y – matrice 3 x 3 ——————-
    //  1  2  1
    //  0  0  0
    //  -1  -2  -1

    int GY[][] = new int[3][3];

    // 3×3 Sobel Mask for Y
    GY[0][0] =  1;
    GY[0][1] =  2;
    GY[0][2] =  1;
    GY[1][0] =  0;
    GY[1][1] =  0;
    GY[1][2] =  0;
    GY[2][0] = –1;
    GY[2][1] = –2;
    GY[2][2] = –1;

    //————- variables de canaux couleurs des pixels ——
    int sumRx = 0;
    int sumGx = 0;
    int sumBx = 0;

    int sumRy = 0;
    int sumGy = 0;
    int sumBy = 0;

    int finalSumR = 0;
    int finalSumG = 0;
    int finalSumB = 0;

   //————— passage en revue des pixels de l’image ————-

    for(int y = 0+1; y < imgSobel.height–1; y++) {// —- défilement des y en excluant la première et dernière ligne
      // car le calcul sobel nécessite 1 pixel autour du pixel calculé

      for(int x = 0+1; x < imgSobel.width–1; x++) { // —- défilement des x en excluant la première et dernière ligne
      // car le calcul sobel nécessite 1 pixel autour du pixel calculé

        // convolution horizontale

          // Convolve across the X axis and return gradiant aproximation
          //——- parcourt les pixels autour du pixel à évaluer – détection lignes horizontales—
          //—- nombre pixels pris en compte = idem taille matrice

          for(int i = –1; i <= 1; i++) {

            for(int j = –1; j <= 1; j++){

              color col =  imgIn.get(x + i, y + j); // récupère la couleur du pixel à prendre en compte à partir image de départ
              float r = red(col); // récupère le rouge
              float g = green(col); // récupère le vert
              float b = blue(col); // récupère le bleu

              sumRx += r * GX[ i + 1][ j + 1]; // applique le masque sur le canal rouge
              sumGx += g * GX[ i + 1][ j + 1]; // applique le masque sur le canal vert
              sumBx += b * GX[ i + 1][ j + 1]; // applique le masque sur le canal bleu

            } // fin for j

          } // fin for i

          // convolution verticale

          //——- parcourt les pixels autour du pixel à évaluer – détection lignes verticales —
          //—- nombre pixels pris en compte = idem taille matrice

          for(int i = –1; i <= 1; i++) {

            for(int j = –1; j <= 1; j++) {

              color col =  imgIn.get(x + i, y + j); // récupère la couleur du pixel à prendre en compte
              float r = red(col); // récupère le rouge
              float g = green(col); // récupère le vert
              float b = blue(col); // récupère le bleu

              sumRy += r * GY[ i + 1][ j + 1]; // applique le masque sur le canal rouge
              sumGy += g * GY[ i + 1][ j + 1]; // applique le masque sur le canal vert
              sumBy += b * GY[ i + 1][ j + 1]; // applique le masque sur le canal bleu

            } // fin for j

          } // fin for i

          //———— valeur finale canaux couleurs —
          finalSumR = abs(sumRx) + abs(sumRy);
          finalSumG = abs(sumGx) + abs(sumGy);
          finalSumB = abs(sumBx) + abs(sumBy);

/*
          // I only want to return a black or a white value, here I determine the greyscale value,
          // and if it is above a tolerance, then set the colour to white

          float gray = (finalSumR + finalSumG + finalSumB) / 3;
          float tolerance=90;

          if(gray > tolerance)
          {
            finalSumR = 0;
            finalSumG = 0;
            finalSumB = 0;
          }
          else
          {
            finalSumR = 255;
            finalSumG = 255;
            finalSumB = 255;
          }

*/

          //—— recalcule les pixels —-
          imgSobel.pixels[ x + (y * imgSobel.width) ] = color(finalSumR, finalSumG, finalSumB);

          //— RAZ des variables —-
          sumRx=0;
          sumGx=0;
          sumBx=0;
          sumRy=0;
          sumGy=0;
          sumBy=0;

        } // fin for x

      } // fin for y

          //img1.updatePixels();  // met à jour les pixels  
          imgSobel.updatePixels();  // met à jour les pixels

          return imgSobel; // renvoie l’image modifiée

    } //—————- fin filtre sobel —————–

//——————— fonction lecture son avec Mplayer SANS sortie Termial —————
void joueSonMplayerNoWait(String cheminSon, String fichierSon) {

 //—— code type pour jouer son avec mplayer par ligne commande (Ubuntu) —-

String[] command = new String[3]; // tableau String pour la ligne de commande

// mplayer /home/hinault/Bureau/mes_sons/r2d2_2.mp3 -quiet
command[0] = « mplayer »;
command[1] = cheminSon+fichierSon;
command[2]=« -quiet »;

//— exécution de la ligne de commande (code Java)

try {
    Process p = exec(command); // exécute la commande
}
  catch (Exception e) { // gestion exception
    e.printStackTrace();

  } //— fin catch

 finally {
        } // fin finally

} //——————— fin joueSonMplayerNoWait

//—- fonction inversion sens d’une image (rotate 180) —

PImage rotateImage(PImage imgIn) {

  PImage imgOut;

  imgOut=imgIn.get(); // crée une image idem

  imgIn.loadPixels(); // charge les pixels de l’image en mémoire
  imgOut.loadPixels(); // charge les pixels de l’image en mémoire

  int nbPixels= (imgIn.width)*(imgIn.height);

  for (int i=0; i<nbPixels; i++) {

    imgOut.pixels[nbPixels–i–1]=imgIn.pixels[i]; // inverse tous les pixels

  }

        imgOut.updatePixels();  // met à jour les pixels de l’image  

        return (imgOut); // renvoi image modifiée

} // fin fonction traitement Image

//———— gestion évènement clavier ———

void keyPressed() {

    println(« Touche appuyée »);  

    if(key==‘ ‘) { // si touche espace enfoncee

      //imgCapture=cam1.get(); // récupère l’image GS video dans Pimage
      //imgCapture=imgDest.get(); // récupère l’image traitée

      image(imgCapture, widthCapture*2, 0); // affiche image

      joueSonMplayerNoWait(cheminFichierSon,« camera-click-1.wav »);
      println(« Photo prise! »);

        }

    if(key==‘e’) { // si touche e enfoncee

      imgCapture.save(cheminFichierImage+nomFichierImage);
      joueSonMplayerNoWait(cheminFichierSon,« electric-drill-3.mp3 »);
      println(« Photo enregistrée! »);

        }

}

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