Académique Documents
Professionnel Documents
Culture Documents
Universite Hassan 1er
Universite Hassan 1er
S’il est parfaitement adapté à l’automatique et au traitement du signal, sa facilité d’emploi avec des
nombres complexes et ses possibilités d’affichages graphiques en font un outil intéressant pour bien
d’autres types d’applications. De plus, des toolboxes sont disponibles dans de nombreux domaines
(Traitement du signal, traitement d’images, optimisation, contrôle…)
L’objectif de cette introduction au traitement d’images sous Matlab est de présenter la notion d’image et
d’effectuer des opérations simples d’analyse d’images telles que la binarisation, filtrage, séparation des
couleurs.
2.2 Le pixel :
Une image numérique est constituée d’un ensemble de points appelés pixels (abréviation
de PICture Element) pour former une image. Le pixel représente ainsi le plus petit élément
constitutif d’une image numérique. L’ensemble de ces pixels est contenu dans un tableau à deux
dimensions constituant l’image. Le pixel est caractérisé par sa position X et Y (colonnes et lignes), ainsi
que son intensité de lumière (voir niveau de gris pour les images sans couleurs, exemple : images
radiologiques)
Le pixel Yi,j est donc obtenu en faisant une combinaison linéaire (ou moyenne pondérée) du
pixel Xi,j de l'image initiale et de ses 8 proches voisins. La relation ci-dessus se généralise aux noyaux
de convolution 5x5, 7x7, etc.
Exemple de construction d'un histogramme d'une image couleur, dans l'espace RGB, sur les
composantes rouge et bleue uniquement: Chaque composante est quantifiée en quatre intervalles, ce
qui donne un nombre de classes de 42=16. On peut alors représenter la table suivante par un
histogramme 3D, où l'axe X représente la composante bleue, l'axe Y représente la composante rouge
et l'axe vertical est le nombre de pixels de chaque classe. Cet histogramme n'est pas normalisé.
Figure 16 Histogramme 3D
On peut aussi créer des matrices avec la fonction « ones », cette fonction crée des matrices de taille
précisée, respectivement remplies de u.
Code :
>> A = - ones (3,3)
Exécution :
Autre exemple :
Code :
>> B= [ 0 1 0 ; 1 0 1 ; 0 1 0 ]
Exécution :
Code :
>> freqz2(B)
Exécution :
6 Affichage d’une image :
Code :
>> B = [ 0 1 0 ; 1 0 1 ; 0 1 0];
>> imshow(B)
Exécution :
Le résultat ne donne pas une image claire, pour obtenir une image plus clair on utilise le code suivant
Code:
>> imshow(B,'InitialMagnification','fit')
Exécution :
Quelle information peut-on tirez de cette image ?
Pour chaque élément de la matrice B, le 1 représente la couleur blanche et le 0 représente la couleur
noire
Conclure !
Une image est une matrice dont les éléments de la matrice sont les pixels qui sont caractérisé par la
position X et Y, et l’intensité de la lumière comme troisième dimension.
Que remarquez-vous?
Pour chaque colonne de la matrice, on divise les éléments de la colonne par 6. Pour i allant de 0 à 6,
on effectue l’opération suivante i/6
Pour afficher l’image I et l’image In (niveaux de gris) :
Code:
>> subplot(221);
>> imshow(I);
>> subplot(222);
>> imshow(In)
Exécution:
Taille de l’image:
Code:
>> size(I)
Exécution:
Histogramme de l’image:
Code:
>> imhist(I)
Exécution:
Interpréter !
Les niveaux de gris moyens & proches du noir sont les plus dominants par contre les niveaux de gris
proches du blanc sont négligeables
8 Binarisation :
La binarisation est un procédé qui produit seulement deux types de pixels dans une image : des pixels
noirs et des pixels blancs. Elle 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. La binarisation consiste à mettre la valeur 0
tous les pixels dont la valeur n’est pas supérieure à une valeur définie en préalable et à 255 les pixels
dont la valeur est supérieure à ce même seuil. La binarisation peut s’effectuer en utilisant directement
imshow(Image>Seuil).
Code:
>> I=imread('cameraman.tif');
>> imshow(I>50)
Exécution:
Que remarquez-vous de l’histogramme de l’image I ?
L’image est devenue sous forme de deux couleurs noirs et blancs, pas de niveau intermédiaire
On effectue cette opération pour plusieurs valeurs de seuillage et on affiche dans la même fenêtre
l’image initiale avec ces résultats :
Code:
>>subplot(221);imshow(I),title('image');
>>subplot(222);imshow(I>50),title('Seuil>50');
>>subplot(223);imshow(I>80),title('Seuil>80');
>>subplot(224),imshow(I>120),title('Seuil>120');
Exécution:
9 Négatif:
Négatif de l’image ‘CAMERAMAN’
Code:
>> subplot(121),imshow(I),
>> subplot(122),imshow(255-I)
Exécution:
10 Egalisation d’histogramme:
On utilise l’image ‘SPINE’ pour mieux voir l’utilisation d’égalisation
Code:
>> I=imread('spine.tif');
>> J=histeq(I);
>> subplot(221),imshow(I),title('I initiale');
>> subplot(222),imhist(I),title('hist initiale');
>> subplot(223),imhist(J),title('hist egalisée');
>> subplot(224),imshow(J),title('image egalisée')
Exécution:
Interpréter !
L’histogramme initiale était réparti seulement dans la zone noire, mais après l’égalisation il y a une
répartition équitable des pixels et par ceci nous avons pu voir bien l’image.
TP2
Séparation des couleurs
Filtres de bruits & filtre Médian
11 Séparation des couleurs :
Code:
>> I1=imread('football.jpg');imshow(I1)
Execution:
Code:
>>R=I1(:,:,2);G=I1(:,:,2);B=I1(:,:,3);
>> subplot(221);imshow(I1),title('image');
>> subplot(222);imshow(R),title('R');
>> subplot(223);imshow(G),title('G');
>> subplot(224);imshow(B),title('B')
Execution:
RGB vers GRAY:
Code:
>> I=imread('football.jpg');
>> G=rgb2gray(I);
>> imshow(G)
Execution:
12 Filtre de bruit:
Pour améliorer la qualité visuelle de l’image, on doit éliminer les effets des bruits (parasites) en lui
faisant subir un traitement appelé filtrage. Le filtrage consiste à modifier la distribution fréquentielle des
composantes du signal selon des spécifications données. Le système linéaire utilisé est appelé filtre
numérique.
D’abord on va bruiter l’image initiale par deux bruits ; il s’agit de :
Gaussian
Salt & Peper
Code:
>> I=imread('cameraman.tif');
>> ib1=imnoise(I,'gaussian',0.0,0.01);
>> ib2=imnoise(I,'salt & pepper');
>> subplot(131);imshow(I),title('image initiale');
>> subplot(132;imshow(ib1),title('image guassian');
subplot(132;imshow(ib1),title('image guassian');
>> subplot(132);imshow(ib1),title('image guassian');
>> subplot(133);imshow(ib2),title('image salt&pepper')
Application du filter moyenneur sur les bruits:
On crée des masques h1, h2 et h3 :
Code:
>> h1=(1/9)*ones(3,3);h2=(1/25)*ones(5,5);h3=(1/49)*ones(7,7);
>> Ifiltre1=imfilter(ib1,h1);
>> Ifiltre2=imfilter(ib1,h2);
>> Ifiltre3=imfilter(ib1,h3);
>> subplot(221),imshow(ib1),title('image gaussienne');
>> subplot(222),imshow(Ifiltre1),title('ib1+h1');
>> subplot(223),imshow(Ifiltre2),title('ib1+h2');
>> subplot(224),imshow(Ifiltre3),title('ib1+h3')
Exécution:
Résultats :
Elimination du bruit granuleux
L’image est plus floue qu’avant
Interprétation :
Ce sont des filtres passe-bas qui lisse l’image, du fait qu’ils ont éliminés les détails fins de l’image
Maintenant, on va appliquer le filtre moyenneur sur le bruit Salt & Pepper :
Code:
>> Ifiltre4=imfilter(ib2,h1);Ifiltre5=imfilter(ib2,h2);Ifiltre6=imfilter(ib2,h3);
>> subplot(221),imshow(ib2),title('image Salt & Pepper');
>> subplot(222),imshow(Ifiltre4),title('ib2+h1');
>> subplot(223),imshow(Ifiltre5),title('ib2+h2');
>> subplot(224),imshow(Ifiltre6),title('ib2+h3')
Exécution:
Application du filtre médian sur les bruits:
On va maintenant créer un filtre médian afin de l’appliquer aux trois types de bruits.
Le filtre médian est appliqué à l’image en plus du filtre de bruit gaussien
Code:
>> ib1=imnoise(I,'gaussian');MG=medfilt2(ib1);imshow(MG),title('ib1+MG')
Exécution:
Le filter median est appliqué à l’image en plus du filter de bruit sel et poivre
Code:
>> ib2=imnoise(I,'salt & pepper');MSP=medfilt2(ib2);imshow(MSP),title('ib2+MSP')
Exécution:
Interprétation :
Le filtre médian a la meilleure efficacité sur le cas du bruit sel & poivre par rapport au bruit
Gaussien et il est plus efficace que le filtre moyenneur dans ce cas
TP 3
Détection des contours
‘Application des filtres’
Le travail à faire consiste à comparer les différents algorithmes de détection de contours, pour cela on va
utiliser les filtres PREWITT, SOBEL & ROBERT.
13 Filtre Prewit :
Code:
>> hx=[ -1 -1 -1;0 0 0; 1 1 1];
>> hy=[-1 0 1; -1 0 1;-1 0 1];
>> I=imread('cameraman.tif');
>> I=double(I)/255.0;
>> Gx=imfilter(I,hx);
>> Gy=imfilter(I,hy);
>> Gp=sqrt(Gx.^2+Gy.^2);
>> subplot(221),imshow(I),title('I initiale');
>> subplot(222),imshow(Gx),title('Gx');
>> subplot(223),imshow(Gy),title('Gy');
>> subplot(224),imshow(Gp),title('Gp')
Exécution:
14 Filtre Sobel:
On effectue une detection de contours en utilisant la méthode de Sobel, qui est une méthode rapide, mais
moins efficace sur des images complexes.
Code:
>> Jx=[ -1 -2 -1;0 0 0; 1 2 1];
>> Jy=[ -1 0 1;-2 0 2; -1 0 1];
>> I=imread('cameraman.tif');
>> I=double(I)/255.0;
>> Gx=imfilter(I,Jx);
>> Gy=imfilter(I,Jy);
>> Gs=sqrt(Gx.^2+Gy.^2);
>> subplot(221),imshow(I),title('image initiale');
>> subplot(222),imshow(Gx),title('Gx');
>> subplot(223),imshow(Gy),title('Gy');
>> subplot(224),imshow(Gs),title('Gs')
Exécution:
15 Filtre Robert:
Code:
>> kx=[1 0;0 -1];
>> ky=[0 1;-1 0];
>> I=imread('cameraman.tif');
>> I=double(I)/255.0;
>> Gx=imfilter(I,kx);
>> Gy=imfilter(I,ky);
>> Gr=sqrt(Gx.^2+Gy.^2);
>> subplot(221),imshow(I),title('image initiale');
>> subplot(222),imshow(Gx),title('Gx');
>> subplot(223),imshow(Gy),title('Gy');
>> subplot(224),imshow(Gr),title('Gr')
Exécution:
COMPARAISON:
Le filtre Prewitt a détecté le contour plus que les autres filtres, alors il est le plus performant.
Code:
>> subplot(321),imshow(Gp),title('Gp');
>> subplot(322),imhist(Gp),title('Gp');
>> subplot(323),imshow(Gs),title('Gs');
>> subplot(324),imhist(Gs),title('Gs');
>> subplot(325),imshow(Gr),title('Gr');
>> subplot(326),imhist(Gr),title('Gr')
Exécution:
Binarisation:
On va binariser l’image obtenu par chaque filtre puis comparer les résultats:
>> Max1=max(max(Gp));
>> Max2=max(max(Gs));
>> Max3=max(max(Gr));
Seuillage 50 % :
>> subplot(321),imshow(Gp),title('Gp');
>> subplot(322),imshow(Gp>0.5*Max1,'InitialMagnification','fit'),title('Gp:seuil=0.5');
>> subplot(323),imshow(Gs),title('Gs');
>> subplot(324),imshow(Gs>0.5*Max2,'InitialMagnification','fit'),title('Gs:seuil=0.5');
>> subplot(325),imshow(Gr),title('Gr');
>> subplot(326),imshow(Gr>0.5*Max3,'InitialMagnification','fit'),title('Gr:seuil=0.5');
Seuillage 25 % :
>> subplot(321),imshow(Gp),title('Gp');
>> subplot(322),imshow(Gp>0.25*Max1,'InitialMagnification','fit'),title('Gp:seuil=0.25');
>> subplot(323),imshow(Gs),title('Gs');
>> subplot(324),imshow(Gs>0.25*Max2,'InitialMagnification','fit'),title('Gs:seuil=0.25');
>> subplot(325),imshow(Gr),title('Gr');
>> subplot(326),imshow(Gr>0.25*Max3,'InitialMagnification','fit'),title('Gr:seuil=0.25')
TP 4:
Applications sur la transformée de
Fourier
Exemple 1 :
>> fo=2000;
>> fe=8000;
>> te=1/fe;
>> k=0:1:1024;
>> x=cos(2*pi*fo*k*te);
>> plot(k,x);
>> z=fft(k,x);
>> m=length(z);
>> f=(-m/2:m/2-1)*(fe/m);
>> y=fftshift(z);
>> po=y.*conj(y)/m;
>> plot(f,po)
Exemple 2 :fenêtre rectangle
>> te=0.01;
>> t=-0.5:te:1.5;
>> N=101;
>> Wr=zeros(1,50);
>> Wr=[Wr,ones(1,N-1)];
>> Wr=[Wr,zeros(1,51)];
>> wr=(fft(Wr));
>> wr=fftshift(wr);
>> subplot(2,1,1);plot(t,Wr);
>> title('rectangle');
>> subplot(2,1,2);plot(t,abs(wr),'r');title('fft(rectangle)')
Exemple 3 :haning
>> te=0.01;
>> t=-0.5:te:1.5;
>> N=100;
>> n=zeros(1,N/2);
>> n=[n,(0:N)];
>> n=[n,zeros(1,N/2)];
>> Wc=0.5*(1-cos(2*pi*(n)/N));
>> wc=(fft(Wc));
>> wc=fftshift(wc);
>> subplot(2,1,1);plot(t,Wc);title('HANIING');
>> xlabel('t');
>> subplot(2,1,2);plot(t,abs(wc),'r');title('fft(haning)')
Exemple 4 :haming
>> te=0.01;
>> t=-0.5:te:1.5;
>> N=100;
>> n=zeros(1,N/2);
>> n=[n,(0:N)];
>> n=[n,zeros(1,N/2)];
>> Wh=0.54-0.46*(1-cos(2*pi*(n)/N));
>> wh=(fft(Wh));
>> wh=fftshift(wh);
>> subplot(2,1,1);plot(t,Wh);title('HAMINNG');
>> xlabel('t');
>> subplot(2,1,2);plot(t,abs(wh),'r');title('fft(haming)')
TP 5:
Applications des filtres sur des
images
Filtre passe haut
I = imread(' IMG_E7868.jpg');
F=fftshift(fft2(I));
%calcul de la taille de l'image;
M=size(F,1);
N=size(F,2);
P=size(F,3);
H1=ones(M,N);
D0=2;
M2=round(M/2);
N2=round(N/2);
H1(M2-D0:M2+D0,N2-D0:N2+D0)=0;
for i=1:M
for j=1:N
G(i,j)=F(i,j)*H1(i,j);
end
end
g=ifft2(G);
subplot(1,2,1);imshow(I);title('Image originale');
subplot(1,2,2);imshow(255-abs(g),[0,255]);title('Image filtrée');
Filtre passe bas
I = imread(IMG_E7868.jpg');
F=fftshift(fft2(I));
%calcul de la taille de l'image;
M=size(F,1);
N=size(F,2);
P=size(F,3);
H0=zeros(M,N);
D0=3;
M2=round(M/2);
N2=round(N/2);
H0(M2-D0:M2+D0,N2-D0:N2+D0)=1;
for i=1:M
for j=1:N
G(i,j)=F(i,j)*H0(i,j);
end
end
g=ifft2(G);
subplot(1,2,1);imshow(I);title('Image originale');
subplot(1,2,2);imshow(abs(g),[0,255]);title('Image filtrée');