COMPTE RENDUS DES TRAVAUX PRATIQUES DE LA PREMIERE PARTIE DU TRAITEMENT D’IMAGE Par Mahmoud Zyate Et Abdelhalim Kamrani
Enseignants : M. ZARGHILI Arsalane
Sommaire Sommaire.....................................................................................................2 Introduction..................................................................................................3 TP2 : Histogramme et Binarisation..............................................................4 Histogramme............................................................................................4 Egalisation d’histogramme....................................................................4 Etirement de l’histogramme..................................................................5 Comparaison entre l’étirement et l’égalisation.....................................5 Binarisation...............................................................................................6 Binarisation locale.................................................................................6 Binarisation globale : méthode d’OTSU.................................................7 TP 3 : Filtrage Spatial...................................................................................9 Filtrage linéaire.........................................................................................9 Filtre moyenneur...................................................................................9 Filtre gaussien......................................................................................10 Filtrage non linéaire................................................................................11 Filtre médian........................................................................................11 TP 4 : Filtrage fréquentiel...........................................................................13 Filtre passe-bas, filtre passe-haut........................................................13
Introduction L’objectif de ces travaux pratiques est de nous faire manipuler les différentes techniques de traitement d’image tout en utilisant Matlab. Il nous faudra créer des scripts et des fonctions selon le contexte sur Matlab afin de réaliser les différents exercices.
En accompagnement de ce document, les fonctions et scripts expliqués dans ce rapport.
TP2 : Histogramme et Binarisation Dans ce TP, nous étudierons l’histogramme, la binarisation que ce soit globale, locale ou hybride, l’étirement et l’égalisation.
Histogramme L’histogramme d’une image en niveau de gris associe à chaque valeur d’intensité le nombre de pixels prenant cette valeur. Pour créer l’histogramme d’une image en niveau de gris, il suffit de parcourir l’image pour compter le nombre de pixels de chaque valeur. Voici, en langage Matlab, la méthode de calcul de l’histogramme d’une image en niveau de gris dans une fonction qu’on nomme im_histo. function[W]=im_histo(A) %fonction permettant de calculer l'histogramme de l'image A %On commence par initialiser une matrice d'une ligne et 256 colonne %avec des zeros W=zeros(1,256); [p,q]=size(A); %on parcours ensuite notre image for i=1: p for j=1: q %pour chaque pixel rencontré, on incrémente sa valeur de 1 dans %notre vecteur W x=A(i,j)+1; W(x)=W(x)+1; end end %bar(W) %à ajouter si on veut que la fonction retourne le dessin du %vecteur en bars plutôt que le vecteur uniquement End
La fonction Matlab imhist permet également de calculer l’histogramme d’une image. Cette fonction est plus optimisée par rapport à la nôtre.
Egalisation d’histogramme Cette transformation consiste à rendre le plus plat possible l’histogramme des niveaux de gris de l’image, de façon à harmoniser la répartition des niveaux de luminosité de l’image. Cette opération vise à augmenter les nuances dans l’image, c’est-à-dire à renforcer le contraste sur des détails de l’image qui sont masqués par des variations d’intensité de plus grande amplitude et à plus grande échelle. Le code correspondant à cette opération est le suivant, sachant que MATLAB a déjà implémenté ce fonctionnement dans sa fonction histeq :
function[Ieq]=Histo_eq(A) %fonction permetant d'égaliser une image A passée en paramètre [p,q]=size(A); Hn=im_histo(A)/(p*q); function[v]=C(k) %fonction qui va nous permetre de calculer la densité de %probabilité cumulative. v=0; for l=1: k+1 v=v+Hn(l); end end for i=1: p for j=1: q Ieq(i,j)=C(A(i,j))*255; end end Ieq=uint8(Ieq); %rendre les valeurs de Ieq des entiers. end
Etirement de l’histogramme Cette méthode élémentaire consiste à utiliser au mieux l’échelle de niveaux de gris disponibles sur le système d’acquisition d’image. Ceci revient à étendre l’histogramme afin que la valeur d’intensité la plus faible soit à zéro et que la valeur la plus haute soit à la valeur maximale. De cette façon, si les valeurs de l’histogramme sont très proches les unes des autres, l’étirement va permettre de fournir une meilleure répartition afin de rendre les pixels clairs encore plus clairs et les pixels foncés proches du noir. Il est ainsi possible d’augmenter le contraste d’une image. On peut coder ce procédé sous MATLAB de la manière suivante : function[Iet]=Histo_Etire(A) %fonction permetant l'étirement d'un histogramme [p,q]=size(A); B=double(A); pmax=max(max(B)); % la valeur maximale dans l'image pmin=min(min(B)); % la valeur minimale dans l'image
end
for i=1: p for j=1: q a=double(B(i,j)-pmin); b=double(pmax-pmin); c=double(a/b); d=double(255*c); Iet(i,j)=uint8(d); end end
Bien entendu, l’équivalent MATLAB est la fonction imadjust.
Comparaison entre l’étirement et l’égalisation Ces deux traitements ont pour but de renforcer le contraste d’une image. Dans les deux cas, l’image traitée présente cependant du bruit, chose aisément contournable à l’aide d’un filtre. L’égalisation d’histogramme semble plus utile avec une image complexe, en effet l’étirement d’histogramme n’a rien à faire sur une image possédant déjà les 255 niveaux de gris, et le changement de contraste est alors très peu visible.
Binarisation La binarisation est un procédé qui produit seulement deux types de pixels dans une image : des pixels noirs et des pixels blancs. La binarisation permet donc de transformer une image ou un flux en noir et blanc. Il faut pour cela déterminer un seuil : quels sont les pixels qui doivent-être noirs et ceux qui doivent-être blancs ? Nous pouvons pour cela utiliser l’histogramme. Une fois l’histogramme de l’image en notre possession, il faut établir une somme cumulée des intensités, c’est à dire faire la somme du nombre de pixels pondéré par leurs intensités. Pour établir le seuil, il suffit alors de diviser cette somme par la taille de la matrice de notre image. Il existe également d’autres méthodes. La fonction MATLAB, im2bw, permet de binariser une image selon un seuil donné en paramètres. Son code ressemble au suivant : function[Ibin]=im_bin(I,s) %fonction qui binarise une image selon un seuil donné [p,q]=size(I); for i=1: p for j=1: q if I(i,j)>s Ibin(i,j)=255; else Ibin(i,j)=0; end end end Ibin=uint8(Ibin); end
Binarisation locale Dans la binarisation locale, le choix de seuil se fait sur une fenêtre de l’image : on divise l’image dans notre traitement en blocs. En d’autres termes, le seuil est la valeur moyenne de cette fenêtre.
On a implémenté sous MATLAB une fonction qui permet de binariser une image localement avec la taille de fenêtre qui faut prendre en considération passée en paramètre : function[bnl]=binarisation_locale(Im,tb) %fonction de binarisation locale %Im étant l'image à binariser et tb la taille du bloc pour déterminer %le seuil local [p,q]=size(Im); nbrbloci=(p-mod(p,tb))/tb;% Quantification du nombre de blocs compris nbrblocj=(q-mod(q,tb))/tb;% dans l'image %check=1; cptbloci=0; for i=1:tb: p cptblocj=0; for j=1:tb: q %vérifier si on a dépassé le dernier bloc des lignes if cptbloci==nbrbloci n=i+mod(p,tb)-1; else n=i+tb-1; end %vérifier si on a dépassé le dernier bloc des colonnes if cptblocj==nbrblocj m=j+mod(q,tb)-1; else m=j+tb-1; end bloc=Im([i:n],[j:m]); [x,y]=size(bloc); mi=min(min(bloc)); ma=max(max(bloc)); S=(mi+ma)/2; %bnl([i:n],[j:m])=im_bin(bloc,s); appel de la fonction %précédente
%%% % % % % % % % %%%
for r=1: x for s=1: y if bloc(r,s)> S bnl(i+r-1,j+s-1)=255; else bnl(i+r-1,j+s-1)=0; end end end Code utilisé pour confirmer que la division en blocks est juste if(check==0) bnl([i:n],[j:m])=zeros(x,y); check=1; else bnl([i:n],[j:m])=ones(x,y)*255; check=0; end %calculer le nombre de blocs des colonnes cptblocj=cptblocj+1;
end %calculer le nombre de blocs des lignes cptbloci=cptbloci+1;
end
end
Binarisation globale : méthode d’OTSU Comme on a cité avant, quand on binarise globalement, le choix de seuil se fait au dépend de tous les pixels de l’image. L’algorithme de OTSU se base surtout sur l’histogramme d’intensité. function [ Ibn ] = binarisation_globale( Image ) %fonction de binarisation globale selon le modèle d'OTSU H=im_histo(Image); %vecteur d'histogramme où pour la valeur i d'un pixel %on calcule sa fréquence dans H(i+1) N=size(Image,1)*size(Image,2); % nombre total des pixels pct = 0; for i=1:256 pct = pct + (i-1)* H(i); %produit cummulable total de la valeur x et sa fréquence. end pcB=0; %produit cumulable du background VarBmax=0; seuil=0; wB = 0; wF = 0; for i=1:256 wB = wB+ H(i); if wB==0 continue; end wF = N- wB; if wF==0 break; end pcB = pcB + (i-1)*H(i); MeanB= pcB/wB; MeanF= (pct-pcB)/wF; varB= wB/N * wF/N * MeanB * MeanF; if varB>VarBmax VarBmax=varB; seuil=i-1; end %une fois notre seuil calculé, on peut maintenant binariser l'image Ibn=im2bw(Image,seuil/256); end
end
Sous MATLAB, la fonction graytresh utilise la méthode d’Otsu. Pour utiliser cette méthode, il faut commencer par établir le seuil avec la
fonction graytresh, puis binariser l’image en utilisant ce seuil à l’aide de la fonction im2bw. otsu=graythresh(ndg); bw=im2bw(ndg,otsu);
TP 3 : Filtrage Spatial Le terme spatial se réfère à l’ensemble des pixels composant l’image. Tout traitement spatial peut s’exprimer comme Où I est l’image originale, J l’image traitée, et T est un opérateur sur I, défini sur un voisinage de (x, y). Si ce voisinage est de taille 1, T agit pixel par pixel, et on parle alors d’analyse point à point. On récupère alors entre autres les méthodes d’analyse d’histogramme, auxquelles on adjoint toute transformation mathématique i →T(i) (logarithmique, exponentielle, ...) Nous allons nous intéresser aux filtres linéaires et non linéaires
Filtrage linéaire Les filtres linéaires sont fondés sur l’hypothèse de linéarité du système d’acquisition. Les filtres dits passe-bas atténuent ou éliminent les hautes fréquences spatiales dans l’image, en laissant les basses fréquences intactes. Au contraire, un filtre passe haut laisse intactes les hautes fréquences, et atténue les basses. Ce filtre transforme un ensemble de données d'entrée en un ensemble de données de sortie selon l’opération mathématique appelée convolution.
Filtre moyenneur Ce filtre lisseur part du principe que la valeur d'un pixel est relativement similaire à son voisinage. Il fait donc en sorte que chaque pixel est remplacé par la moyenne pondérée de ses voisins. Si on applique un filtre moyenneur de taille d=3, cela signifie qu'on additionne la valeur de tous les pixels du voisinage du pixel traité.
On a implémenté ce principe dans la fonction suivante, bien sûr il faut donner en paramètre la matrice du filtre. function[Ifil]=filt_moy(I,h) %filtre de moyennage [p,q]=size(I); d=length(h); %dimention du filtre %puisque les bords seront remplis par des 0, on calcul la taille de ces %bord en dépend de la dimention du filtre lim=(d-1)/2; Ifil=zeros(p,q); %on crée ensuite une duplication où on insère des bords fictifs , si par %exemple l'image est de taille 200*200 et le filtre 3*3, on insère l'image %dans une matrice de taille 202*202. Idup=zeros(p+2*lim,q+2*lim); Idup([1+lim:p+lim],[1+lim:q+lim])=I;
for i=1+lim:p+lim for j=1+lim:1:q+lim for k=-lim:lim for l=-lim:1:lim Ifil(i-lim,j-lim)=Ifil(i-lim,j-lim)+Idup(i+k,j+l); end end Ifil(i-lim,j-lim)=Ifil(i-lim,j-lim)/power(d,2); end end Ifil= uint8(Ifil); %transformer les valeurs de l'image filtrée en entiers. end
Les effets du filtre moyenneur varient avec la taille du noyau : plus les dimensions du noyau seront importantes, plus le bruit sera éliminé ; mais en contrepartie, les détails fins seront eux-aussi effacés et les contours étalés.
Filtre gaussien L’effet de ce filtre sur l’image est assez similaire au filtre moyenneur, mais la moyenne est pondérée : les pixels près du centre ont un poids plus important que ceux que les autres. En général, un filtre Gaussien avec σ<1 est utilisé pour réduire le bruit, et si σ>1 c’est dans le but de flouter volontairement l'image. Il faut noter que plus σ est grand, plus la cloche Gaussienne est large et plus le flou appliqué à l’image sera marqué. On a implémenté le filtre de la façon suivante en se basant sur la même logique du filtre précédant : function [ Ifil ] = Gaussian(I, sigma ) matrice = [exp(-2/(power(sigma,2))) ,exp(-1/2*(sigma*sigma)),exp(-2/ (power(sigma,2))), exp(-1/2*(sigma*sigma)),1,exp(-1/2*(sigma*sigma)), exp(-2/(power(sigma,2))),exp(-1/2*(sigma*sigma)),exp(-2/(power(sigma,2)))
]; %on a concideré la matrice comme vecteur pour faciliter le balayage coef = 1/(2*pi*power(sigma,2)); [p,q]=size(I); lim=1; % (d-1)/2 , puisque d = 3 lim =1 %même logique que pour le filtre median et moyenneur concernnt les bordures Ifil=zeros(p,q); Idup=zeros(p+2*lim,q+2*lim); Idup([1+lim:p+lim],[1+lim:q+lim])=I;
for i=1+lim:p+lim for j=1+lim:1:q+lim v=1; for k=-lim:lim for l=-lim:1:lim Ifil(i-lim,j-lim)=Ifil(i-lim,j-lim) +Idup(i+k,j+l)*matrice(v); v=v+1; end end
end
Ifil(i-lim,j-lim)=Ifil(i-lim,j-lim)/coef; %normalisation
end Ifil = uint8(Ifil); end
Filtrage non linéaire Cette opération a été développée pour pallier aux insuffisances des filtres linéaires : principalement la mauvaise conservation des contours. Elle a le défaut d'infliger des déformations irréversibles à l'image. Nous ne développerons pas ici de théorie des filtres non-linéaires : ils sont chacun basés sur des bases mathématiques ou empiriques différentes. Ainsi on s’est intéressé dans ce TP au filtre médian.
Filtre médian Le niveau de gris du pixel central est remplacé par la valeur médiane de tous les pixels de la fenêtre d'analyse centrée sur le pixel. La taille du noyau dépend de la fréquence du bruit et de la taille des détails significatifs de l'image traitée. L’implémentation MATLAB équivalente est la suivante : function [ Ifil ] = filt_med(I, dim) %fonction permettant d'appliquer le filtre median sur une image I suivant %une dimention dim donnée.
[p,q]=size(I); %puisque les bords seront remplis par des 0, on calcul la taille de ces %bord en dépend de la dimention du filtre lim=(dim-1)/2; Ifil=zeros(p,q); Vecteur=zeros(1,dim*dim); %on crée ensuite une duplication où on insère des bords fictifs , si par %exemple l'image est de taille 200*200 et le filtre 3*3, on insère l'image %dans une matrice de taille 202*202. Idup=zeros(p+2*lim,q+2*lim); Idup([1+lim:p+lim],[1+lim:q+lim])=I;
for i=1+lim:p+lim for j=1+lim:1:q+lim v=1; %indice de notre vecteur for k=-lim:lim for l=-lim:1:lim %pour chaque valeur de notre fenêtre ou bloc, on l'ajoute %au vecteur. Vecteur(v)=Idup(i+k,j+l); v=v+1; end end Vecteur=sort(Vecteur); % il faut trier notre vecteur de valeurs indiceMedian=(power(dim,2)-1)/2 +1; %indice où se trouve la valeur mediane Ifil(i-lim,j-lim)=Vecteur(indiceMedian); end end Ifil= uint8(Ifil); %transformer les valeurs de l'image filtrée en entiers. end
TP 4 : Filtrage fréquentiel Bien entendu, Une image est avant tout un signal. Les signaux 2D présentent des variations d'intensité (lumineuse) dans l'espace. La transformée de Fourier permet de passer du domaine spatial dans le domaine fréquentiel. La transformée de Fourier du produit de convolution de deux fonctions n'est autre que le produit (classique celui-là) de leur transformée de Fourier et réciproquement. On peut donc utiliser de façon équivalente un filtre spatial ou fréquentiel. Ce dernier n'étant qu'une simple multiplication, il est moins coûteux. Sous MATLAB, la transformation de l’image se fait par la fonction fft2, pour la transformation inverse on exécute la fonction ifft2. La fonction fftshift nous permet de réarranger le résultat de fft2. L’exécution de cette partie-là du TP est en attachement (Script TP4PartieI.m).
Filtre passe-bas, filtre passe-haut Concernant la partie où on doit réaliser le filtre passe-bas et le filtre passe-haut. On a essayé d’appliquer au maximum le cours mais on n’est pas aussi certain des résultats. Le script TP4PartieII.m concerne ce traitement.
