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 – Traitement d'image : Filtre Sobel 2D (détection de contours)

Par X. HINAULT. 11 Mai 2011

Explication

  • Le filtre Sobel est un filtre par convolution utilisé pour détecter les contours dans une image.
  • Ce filtre existe en version verticale, horizontale, où les 2 (c'est la version présentée ici).
  • Ce filtre est plus efficace si il est précédé d'une atténuation du bruit de l'image par un filtre Gaussien.

Ressources utiles

Le masque de convolution utilisé

  • Le masque de convolution utilisé pour la détection des contours horizontaux :

{$ [(-1,0,1),(-2,0,2),(-1,0,1)]$}

  • Le masque de convolution utilisé pour la détection des contours verticaux :

{$ [(1,2,1),(0,0,0),(-1,-2,-1)]$}

Mon code de filtre Sobel 2D


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

    // 3x3 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];

    // 3x3 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);


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

Voir également : Mes fonctions Processing de traitement d'image