Logo Mon Club Elec

Processing – Traitement d’image : Filtre Gaussien (flou, atténuation du bruit)

Le traitement d’image est une technologie qui permet de modifier des images numériques pour obtenir des résultats souhaités. Un des outils les plus populaires pour le traitement d’image est le filtre Gaussien, qui est utilisé pour flouter des images et atténuer le bruit. Ce filtre est très utile pour améliorer la qualité des images et pour obtenir des résultats plus précis. Dans cet article, nous allons examiner en détail le filtre Gaussien et ses applications dans le traitement d’image.

Processing – Traitement d’image : Filtre Gaussien (flou, atténuation du bruit)

Par X. HINAULT. 11 Mai 2011

Processing – Traitement d’image : Filtre Gaussien (flou, atténuation du bruit)

Explication

  • Le filtre Gaussien est un filtre de traitement d’image appliqué par convolution (utilise un masque (matrice) appliqué à chaque pixel)
  • Ce type de filtre est utilisé pour diminuer le bruit ou ou appliquer un flou sur une image.

Ressources utiles

La fonction Gaussienne 2D :

Voir : Scilab : tracé de la courbe gaussienne G(x,y)

Approximation discrète (= en valeur entière) de la courbe de Gaussienne 2D

Approximation 3×3 de la courbe Gaussienne 2D

En fixant sigma = 0.8 et coeff = 16, j’obtiens (retrouve..) dans le tableur LibreOffice le noyau de convolution suivant :

  • En fixant sigma = 0.8 et coeff = 1444, j’obtiens (retrouve..) dans le tableur LibreOffice le noyau de convolution gaussien 2D en 5×5 suivant :

Mon code de filtre Gaussien 3×3

//xxxxxxxxxxxxxxxxxxxx fonction filtre Gaussien 3×3 – diminution bruit xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
// www.mon-club-elec.fr – Par X.HINAULT – Tous droits réservés – Mai 2011 – Licence GPL

PImage filtreGaussien3x3 (PImage imgIn) { //————- début fonction filtre Gaussien 3×3 ——————-

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

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

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

    //————- définition du masque  filtre Gaussien – matrice 3 x 3 ————-  
    //          
    //          | 1  2  1 |    
    //  1/16 x  | 2  4  2 |
    //          | 1  2  1 |
    //
    // ce masque est une approximation discrète simplifiée de la fonction Gaussienne 2D
    // pour sigma = 0.8    

    int Masque[][] = new int[3][3];

    // 3×3  Mask
    Masque[0][0] = 1;
    Masque[0][1] = 2;
    Masque[0][2] = 1;
    Masque[1][0] = 2;
    Masque[1][1] = 4;
    Masque[1][2] = 2;
    Masque[2][0] = 1;
    Masque[2][1] = 2;
    Masque[2][2] = 1;

    int coeffMasque=16; //

    //————- variables de canaux couleurs des pixels ——
    int sumR = 0;
    int sumG = 0;
    int sumB = 0;

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

    for(int y = 0+1; y < imgOut.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 < imgOut.width1; x++) { // —- défilement des x en excluant la première et dernière ligne
      // car le calcul nécessite 1 pixel autour du pixel calculé

          //—- parcourt les pixels autour 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

              sumR = sumR + (int(r) * Masque[ i + 1][ j + 1]/coeffMasque); // applique le masque sur le canal rouge
              sumG = sumG + (int(g) *Masque[ i + 1][ j + 1]/coeffMasque); // applique le masque sur le canal vert
              sumB = sumB + (int(b) *Masque[ i + 1][ j + 1]/coeffMasque); // applique le masque sur le canal bleu

            } // fin for j

          } // fin for i

             constrain(sumR,0,255);
             constrain(sumG,0,255);
             constrain(sumB,0,255);

          //—— recalcule les pixels —-
          imgOut.pixels[ x + (y * imgOut.width) ] = color(sumR, sumG, sumB);

          //— RAZ des variables —-
          sumR=0;
          sumG=0;
          sumB=0;

        } // fin for x

      } // fin for y

          imgOut.updatePixels();  // met à jour les pixels

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

    } //—————- fin filtre Gaussien 3×3 —————–
 

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

Mon code de filtre Gaussien 5×5

//xxxxxxxxxxxxxxxxxxxx fonction filtre Gaussien 5×5 – diminution bruit xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
// www.mon-club-elec.fr – Par X.HINAULT – Tous droits réservés – Mai 2011 – Licence GPL

PImage filtreGaussien5x5 (PImage imgIn) { //————- début fonction filtre Gaussien 3×3 ——————-

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

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

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

    //————- définition du masque  filtre Gaussien – matrice 3 x 3 ————-  
    //          
    //            | 1    7    16   7    1 |    
    //            | 7    75  164  75    7 |    
    //  1/1444 x  | 16  164  359  164  16 |
    //            | 7    75  164  75    7|
    //            | 1    7    16   7    1 |    
    //
    // ce masque est une approximation discrète simplifiée de la fonction Gaussienne 2D
    // pour sigma = 0.8    

    int Masque[][] = new int[5][5];

    // 5×5  Mask
    Masque[0][0] = 1;
    Masque[0][1] = 7;
    Masque[0][2] = 16;
    Masque[0][3] = 7;
    Masque[0][4] = 1;

    Masque[1][0] = 7;
    Masque[1][1] = 75;
    Masque[1][2] = 164;
    Masque[1][3] = 75;
    Masque[1][4] = 7;

    Masque[2][0] = 16;
    Masque[2][1] = 164;
    Masque[2][2] = 359;
    Masque[2][3] = 164;
    Masque[2][4] = 16;

    Masque[3][0] = 7;
    Masque[3][1] = 75;
    Masque[3][2] = 164;
    Masque[3][3] = 75;
    Masque[3][4] = 7;

    Masque[4][0] = 1;
    Masque[4][1] = 7;
    Masque[4][2] = 16;
    Masque[4][3] = 7;
    Masque[4][4] = 1;

    int coeffMasque=1444; //

    //————- variables de canaux couleurs des pixels ——
    int sumR = 0;
    int sumG = 0;
    int sumB = 0;

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

    for(int y = 0+1; y < imgOut.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 < imgOut.width1; x++) { // —- défilement des x en excluant la première et dernière ligne
      // car le calcul nécessite 1 pixel autour du pixel calculé

          //—- parcourt les pixels autour pris en compte = idem taille matrice

          for(int i = 2; i <= 2; i++) {

            for(int j = 2; j <= 2; 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

              sumR = sumR + (int(r) * Masque[ i + 2][ j + 2]/coeffMasque); // applique le masque sur le canal rouge
              sumG = sumG + (int(g) *Masque[ i + 2][ j + 2]/coeffMasque); // applique le masque sur le canal vert
              sumB = sumB + (int(b) *Masque[ i + 2][ j + 2]/coeffMasque); // applique le masque sur le canal bleu

            } // fin for j

          } // fin for i

             constrain(sumR,0,255);
             constrain(sumG,0,255);
             constrain(sumB,0,255);

          //—— recalcule les pixels —-
          imgOut.pixels[ x + (y * imgOut.width) ] = color(sumR, sumG, sumB);

          //— RAZ des variables —-
          sumR=0;
          sumG=0;
          sumB=0;

        } // fin for x

      } // fin for y

          imgOut.updatePixels();  // met à jour les pixels

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

    } //—————- fin filtre Gaussien 5×5 —————–
 

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é.