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 Gaussien (flou, atténuation du bruit)

Par X. HINAULT. 11 Mai 2011

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 3x3 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 5x5 suivant :

Mon code de filtre Gaussien 3x3


//xxxxxxxxxxxxxxxxxxxx fonction filtre Gaussien 3x3 - 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 3x3 -------------------

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

    // 3x3  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.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 < imgOut.width-1; 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 3x3 -----------------
 

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

Mon code de filtre Gaussien 5x5


//xxxxxxxxxxxxxxxxxxxx fonction filtre Gaussien 5x5 - 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 3x3 -------------------

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

    // 5x5  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.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 < imgOut.width-1; 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 5x5 -----------------
 

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