// 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/10/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 la librairie javacv qui implémente les fonctions natives d’OpenCV en Java

/*
Test de l’utilisation de la fonction native filter2D qui permet la réalisation de filtre par noyau de convolution personnalié
*/

// XXXXXXXXXXXXXXXXXXXXXX ENTETE DECLARATIVE XXXXXXXXXXXXXXXXXXXXXX

// inclusion des librairies utilisées

import com.googlecode.javacv.*; // importe librairie javacv
import com.googlecode.javacv.cpp.*; // importe librairie javacv.cpp
// 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) !
// les fonctions de javacv sont dès lors facilement utilisables « in line » dans le code Processing
// la librairie doit simplement être présente dans le répertoire Processing /mode/java/libraries/javacv/library/
// NB : La librairie javacv est basée sur la librairie javacpp du même auteur : http://code.google.com/p/javacpp/

import com.googlecode.javacpp.*; // importe librairie javacpp (à distinguer de javacv.cpp.*)
// librairie javacpp par Samuel Audet : http://code.google.com/p/javacpp/
// la librairie doit être présente dans le même répertoire /mode/java/libraries/javacv/library/

//– autres librairies utiles avec javacv —
import java.awt.image.BufferedImage; // importe la classe java BufferedImage
import java.nio.*; // pour classe ByteBuffer

import java.awt.Rectangle; // importe la classe Rectangle du langage Java
// l’objet rectangle fournit les champs x,y du centre et hauteur/largeur (height/width) du rectangle

// déclaration objets

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

// déclare un/des objets IplImage (conteneur image natif librairie OpenCV) utiles
opencv_core.IplImage iplImgSrc, iplImgDest, iplImgGray, iplImgMask, iplImgTrans, iplImgTransGx, iplImgTransGy, iplImg8UC3_Gx, iplImg8UC3_Gy ;

// 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,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(30);// 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 —

        //======== Code exemple utilisation javacv « in line » =========

  //— chargement d’un fichier image
  String cheminFichier=« /home/hinault/Bureau/trans/monimage.png »; // chemin absolu du fichier utilisé
  iplImgSrc= opencv_highgui.cvLoadImage(cheminFichier); // chargement d’un fichier dans l’IplImage

  opencv_core.CvSize mySize=iplImgSrc.cvSize(); // récupère la taille de l’image – Cvsize est un objet contenant 2 valeurs

  //— création de 2 objets IplImage pour calcul des gradients Sobel en vertical et horizontal
  //iplImgTransGx= opencv_core.cvCreateImage(mySize, iplImgSrc.depth(), iplImgSrc.nChannels()); // crée une image IplImage idem
  //iplImgTransGy= opencv_core.cvCreateImage(mySize, iplImgSrc.depth(), iplImgSrc.nChannels()); // crée une image IplImage idem

  iplImgTrans= opencv_core.cvCreateImage(mySize, opencv_core.IPL_DEPTH_16S, iplImgSrc.nChannels()); // crée une image  IplImage 16S
  opencv_core.cvConvertScale(iplImgSrc, iplImgTrans, 256.0, –32768); // convertit 8U en 16S

  iplImgTransGx= opencv_core.cvCreateImage(mySize, opencv_core.IPL_DEPTH_16S, iplImgSrc.nChannels()); // crée une image IplImage 16S
  iplImgTransGy= opencv_core.cvCreateImage(mySize, opencv_core.IPL_DEPTH_16S, iplImgSrc.nChannels()); // crée une image IplImage 16S

  iplImg8UC3_Gx= opencv_core.cvCreateImage(mySize, opencv_core.IPL_DEPTH_8U, iplImgSrc.nChannels()); // crée une image IplImage 16S
  iplImg8UC3_Gy= opencv_core.cvCreateImage(mySize, opencv_core.IPL_DEPTH_8U, iplImgSrc.nChannels()); // crée une image IplImage 16S

  //— création d’une image IplImage destination —
  iplImgDest= opencv_core.cvCreateImage(mySize, iplImgSrc.depth(), iplImgSrc.nChannels()); // crée une image IplImage idem

  println(« debut: »+millis()); // debug – evaluation durée

  //— initialisation des objets utiles pour le traitement d’image par noyau de convolution

  int kernelSize=3; // pour kernel 3×3

   FloatPointer myPtr = new FloatPointer(kernelSize*kernelSize); // crée un pointeur de (kernelSize x kernelSize) floats pour le noyau

  float value=0.0; // variable calcul kernel normalisé – en fait pas vraiment utilisée ici
  // pour chaque élément du kerne (i,j), on aura : value = (1/kernelSize x kernelSize) * kernel[i][j]

   float coeffNorm=4.0; // coeff pour accentuer le pourtour (= effectuer normalisation partielle du noyau..)

   //— création d’une matrice 2D pour le noyau, de taille kernelSize x kernelSize et de type Float
   //static opencv_core.CvMat   cvMat(int rows, int cols, int type, com.googlecode.javacpp.Pointer data)
   //opencv_core.CvMat matrix=  opencv_core.cvMat(1, 256, opencv_core.CV_16UC1, myPtr) ; // crée un CvMat avec même taille de donnée unitaire
   opencv_core.CvMat matrix2D=  opencv_core.cvMat(kernelSize, kernelSize, opencv_core.CV_32F, myPtr) ; // crée un CvMat avec même taille de donnée unitaire

  //******************* application du noyau Sobel x **********************

   //— définition du noyau de convolution à utiliser —

  // — kernel 3×3 Sobel x —  
   float[][] kernelGx = {{+1,0,-1}, // déclaration des valeurs entières à utiliser
                       {+2,0,-2},
                       {+1,0,-1}};

   //—- remplissage du kernel Gx—-
   for (int i=0; i < kernelSize; i++) {
     for (int j=0; j< kernelSize; j++) {

      value=coeffNorm * kernelGx[i][j] / (kernelSize*kernelSize); // calcul valeur normalisée du kernel – coeffNorm atténue la normalisation et accentue le contour
      //value=kernelGx[i][j]; // si utilisation de la valeur non normalisée. Peut donner meilleur résultat dans certains cas… cf Sobel

    //static void       cvSet2D(opencv_core.CvArr arr, int idx0, int idx1, opencv_core.CvScalar value)
    opencv_core.cvSet2D(matrix2D, i, j, opencv_core.cvScalarAll(value)); // remplit le CvMat à l’index (i,j) voulu  avec la valeur normalisée

    // debug
    //print (« Kernel [« +i+ »] [« +j+ »] = « + kernelGx[i][j]);
    //println( » | Valeur normalisée (« +i+ », »+j+ ») = »+opencv_core.cvGet2D(matrix2D,i,j).val(0)); // lit la valeur (i,j)… utilise fonction .val(index) du scalar renvoyé par cvGet2D

     } // fin j

   } //fin i

  //— application du noyau normalisé à l’image source —
  //static void cvFilter2D(opencv_core.CvArr src, opencv_core.CvArr dst, opencv_core.CvMat kernel, opencv_core.CvPoint anchor)
  opencv_imgproc.cvFilter2D(iplImgTrans, iplImgTransGx, matrix2D, opencv_core.cvPoint (–1,-1)) ;

  //******************* application du noyau Sobel y **********************

  // — kernel 3×3 Sobel y —  
   float[][] kernelGy = {{+1,+2,+1}, // déclaration des valeurs entières à utiliser
                       {0,0,0},
                       {–1,-2,-1}};

   //—- remplissage du kernel Gy—-
   for (int i=0; i < kernelSize; i++) {
     for (int j=0; j< kernelSize; j++) {

      value=coeffNorm * kernelGy[i][j] / (kernelSize*kernelSize); // calcul valeur normalisée du kernel – coeffNorm atténue la normalisation et accentue le contour
      //value=kernelGy[i][j]; // si utilisation de la valeur non normalisée. Peut donner meilleur résultat dans certains cas… cf Sobel

    //static void       cvSet2D(opencv_core.CvArr arr, int idx0, int idx1, opencv_core.CvScalar value)
    opencv_core.cvSet2D(matrix2D, i, j, opencv_core.cvScalarAll(value)); // remplit le CvMat à l’index (i,j) voulu  avec la valeur normalisée

    // debug
    //print (« Kernel [« +i+ »] [« +j+ »] = « + kernelGy[i][j]);
    //println( » | Valeur normalisée (« +i+ », »+j+ ») = »+opencv_core.cvGet2D(matrix2D,i,j).val(0)); // lit la valeur (i,j)… utilise fonction .val(index) du scalar renvoyé par cvGet2D

     } // fin j

   } //fin i

  //— application du noyau normalisé à l’image source —
  //static void cvFilter2D(opencv_core.CvArr src, opencv_core.CvArr dst, opencv_core.CvMat kernel, opencv_core.CvPoint anchor)
  opencv_imgproc.cvFilter2D(iplImgTrans, iplImgTransGy, matrix2D, opencv_core.cvPoint (–1,-1)) ;

  //******************* application des Sobel x et y dans une même image **********************  

  //—- combinaison des 2 gradients sobel vertical et horizontal dans la même image
  //static void cvAdd(opencv_core.CvArr src1, opencv_core.CvArr src2, opencv_core.CvArr dst, opencv_core.CvArr mask)  
  // théoriquement, il faut faire sqrt(Gx² + Gy²)
  // en pratique on peut approximer à |Gx|+|Gy|

  // NB : filter2D renvoie des images 8U non signés si on utilise des image 8U pour le filtre
  // donc on « perd » les valeurs négatives fournies par le Sobel : appliquer par conséquent le Sobel sur valeur 16S

  opencv_core.cvConvertScaleAbs(iplImgTransGx, iplImg8UC3_Gx,1.0/256,0); // passer en valeur absolue et en 8 bits
  opencv_core.cvConvertScaleAbs(iplImgTransGy, iplImg8UC3_Gy,1.0/256,0);

  //opencv_core.cvConvertScale(iplImgTransGx, iplImg8UC3_Gx,1.0/256,64); // didactique – pour visualiser les fronts haut et bas renvoyés par Sobel
  //opencv_core.cvConvertScale(iplImgTransGy, iplImg8UC3_Gy,1.0/256,64);
  // le shift (dernière valeur de la fonction) fixe le niveau moyen de l’image – utiliser < 128 pour éviter image trop blanche…

  //opencv_core.cvConvertScale(iplImgTransGx, iplImgTransGx,1.0/256,128); // non – passer par la valeur absolue et image 8U
  //opencv_core.cvConvertScale(iplImgTransGy, iplImgTransGx,1.0/256,128);

  //opencv_core.cvAdd(iplImgTransGx, iplImgTransGy, iplImgDest,null);
  opencv_core.cvAdd(iplImg8UC3_Gx, iplImg8UC3_Gy, iplImgDest,null);

  println(« fin: »+millis()); // debug – affiche fin durée

  //— affiche IplImage dans Processing via un PImage —
  //imgDest=toPImage(iplImgGray); // transfère IplImage dans PImage
  imgDest=toPImage(iplImgDest); // transfère IplImage dans PImage
  //imgDest=toPImage(iplImgTransGx); // transfère IplImage dans PImage -debug

  image(imgDest,0,0); // affiche le PImage

} // fin fonction Setup

// XXXXXXXXXXXXXXXXXXXXXX Fonction Draw XXXXXXXXXXXXXXXXXXXX

void  draw() { // fonction exécutée en boucle

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

} // fin de la fonction draw()

// XXXXXXXXXXXXXXXXXXXXXX Autres Fonctions XXXXXXXXXXXXXXXXXXXXXX

//—- fonction toPimage : transfère un IplImage dans un PImage

PImage toPImage (opencv_core.IplImage iplImgIn) { // reçoit un IplImage et renvoie un PImage

  //— récupérer l’objet IplImage dans un BufferedImage
  BufferedImage bufImg=iplImgIn.getBufferedImage(); // récupère IplImage dans un objet BufferedImage transitoire

  //—- créer un PImage —
  PImage imgOut = createImage(iplImgIn.width(),iplImgIn.height(), RGB); // création d’un PImage de même taille que IplImage

  // charge les pixels de l’image buffer dans le tableau  imgOut.pixels du PImage
  bufImg.getRGB(0, 0, iplImgIn.width(), iplImgIn.height(), imgOut.pixels, 0,iplImgIn.width());

  imgOut.updatePixels(); // met à jour le PImage

  return(imgOut); // renvoie le PImage

} // fin toPImage

//XXXXXXXXXXXXXXXXXX Fin du programme XXXXXXXXXXXXXXXXX