Logo Mon Club Elec

Processing – Traitement d’image : Filtre Sobel 2D (détection de contours)

Le filtre Sobel 2D est un outil puissant pour la détection de contours dans le traitement d’image. Il est l’un des algorithmes les plus populaires et les plus utilisés pour la détection des contours dans les images. Il est largement utilisé dans le domaine de la vision par ordinateur et est souvent utilisé pour la segmentation des images, la détection des objets et la reconnaissance des formes. Dans cet article, nous allons examiner en détail le fonctionnement du filtre Sobel 2D et ses applications dans le traitement d’image.

Processing – Traitement d’image : Filtre Sobel 2D (détection de contours)

Par X. HINAULT. 11 Mai 2011

Processing – Traitement d’image : Filtre Sobel 2D (détection de contours)

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 :
  • Le masque de convolution utilisé pour la détection des contours verticaux :

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

    // 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.height1; 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.width1; 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

Noter cet article

Laisser un commentaire

Votre adresse e-mail ne sera pas publiée. Les champs obligatoires sont indiqués avec *

Archive Mon Club Elec

Articles populaires

Newsletter

Inscrivez-vous maintenant et bénéficiez d'un soutien continu pour réaliser vos travaux électriques en toute sécurité.