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 : Javacv "inline" : Objet CvMat : Réalisation d'un filtre de Sobel amélioré.

Explications

  • Dans ce programme, on réalise le traitement d'une image à l'aide d'un double traitement par noyau de convolution par filtre de Sobel vertical puis horizontal afin d'extraire les contours. On combine ensuite les 2 résultats obtenus en une seule image.
  • La librairie OpenCv fournit en la fonction native cvSobel qui permet de réaliser un filtre de Sobel sur une image, mais le noyau utilisé est à priori normalisé (c'est à dire que les valeurs du noyau de convolution sont divisées par la taille du noyau). En pratique, cela donne une détection moins franche qu'avec le noyau "brut" non normalisé. Ici, on appliquera donc un coefficient d'atténuation de la normalisation du noyau et donc une accentuation des contours, qui sera ainsi facilement réglable !
  • Le résultat obtenu ici est une détection franche des bords dans une image, tout en limitant les "fausses détections", étape préalable indispensable à la détection des formes ou à l'analyse des contours.

Matériel et configuration utilisés

  • PC Intel Core Quad 2.33 Ghz
  • Ubuntu 10.04 LTS
  • Processing 1-5
  • OpenCV 2.3.1
  • librairie javacv

Ressources utiles

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 : 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 3x3

   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 3x3 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 3x3 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