Vous êtes sur la page 1sur 50

Royaume du Maroc

Université Hassan 1er


Faculté des Sciences & Techniques de Settat
Département de Physique Appliquée
Master en Sciences & Techniques
Génie Biomédical : Instrumentation & Maintenance

Compte rendu des Travaux Pratiques du Module

Traitement & Analyses des images médicales

Travail réalisé par : Encadrant du TP :


Amine Chahid Pr. L. El Abdellaoui
Année Universitaire 2019/2020
Généralités sur les images
numériques
&
Matlab
1 Le logiciel Matlab :
Le logiciel MATLAB (MATrix LABoratory) est spécialisé dans le domaine du calcul matriciel
numérique. Tous les objets définis dans MATLAB le sont donc au moyen de vecteurs et de
matrices/tableaux de nombres. Un ensemble important d’opérateurs et de fonctions MATLAB de base
facilitent leur manipulation et des opérations comme par exemple le produit et l’inversion matricielles
(inv), la transposition (’) ou encore le calcul des valeurs propres (eig) font partie de la bibliothèque
standard. D’autres fonctions servant à la création et à la manipulation de matrices et de tableaux (diag,
fliplr, flipud, rot90, rand, ones, zeros, linspace, logspace) sont également disponibles en nombre.
L’environnement MATLAB se présente sous la forme d’un espace de travail (Workspace), où un
interpréteur de commandes exécute des opérations et fonctions MATLAB. Les sources de celles-ci sont
disponibles, écrites en “ langage ” MATLAB, voire en C ou en Fortran. L’utilisateur peut à sa guise les
modifier, mais en s’en inspirant, il peut surtout créer et rajouter ses propres fonctions.

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.

Figure 1 Environnement de Matlab R2013


2 Caractéristiques des images numériques :
2.1 L’image numérique :
Une image numérique est définie comme un signal bidimensionnel échantillonné à valeurs quantifiées
dans un certain espace de couleurs. Autrement dit, une image numérique est une matrice de valeurs
entières prises sur un intervalle borné. Elle est constituée de pixels.

Figure 2 Signal bidimensionnel (image numérique)

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)

Figure 3 Ensembles de pixels qui forme une image

2.3 La définition de l’image :


On appelle définition le nombre de points (pixels) constituant une image: c’est le nombre de colonnes
de l’image que multiplie son nombre de lignes. Une image possédant 10 colonnes et 11 lignes aura une
définition de 10 x 11 c’est à dire 110 pixels. Ce nombre de pixels est généralement compris entre (640 x
480) et (1800*1300) mais de résolutions supérieures sont techniquement possibles.
Figure 4 Définition d'une image

2.4 La taille de l’image :


Elle se calcule en mesurant la diagonale de l’écran et elle est exprimée en pouces, il faut veiller à ne
pas confondre entre la définition de l’écran et sa taille, une grande taille de l’image implique une
meilleure définition. Un pouce égale à 2,54 cm.

Figure 5 Exemples des tailles des écrans

2.5 Le pas de masque :


Il représente la distance qui sépare deux luminophores de même couleur. Un pas de masque inférieur à
0.25cm procurera un bon confort d’utilisation. Un pas de masque petit implique une meilleure qualité
d’image.

2.6 La résolution de l’image :


Elle détermine le nombre de pixels par unité de surface (pixels par pouces linéaires) traduites points
par pouces. DPI (Dot Per Inch). Une résolution de 300 DPI signifie 300 colonnes et 300 rangés de
pixels par pouce carré ce qui donne 90 000 pixels sur un pouce carré.
Figure 6 Résolutions des images numériques

3 Opérations sur les images numériques :


3.1 La détection des contours :
On appelle détection de contours les procédés permettant de repérer les points d'une image
matricielle qui correspondent à un changement brutal de l'intensité lumineuse. Ces changements de
propriétés de l'image numérique indiquent en général des éléments importants de structure dans l'objet
représenté. Ces éléments incluent des discontinuités dans la profondeur, dans l'orientation d'une
surface, dans les propriétés d'un matériau et dans l'éclairage d'une scène.

Figure 7 Détection des contours

3.1.1 L’opérateur Robert :


L'opérateur de Roberts décrit dans une image rectangulaire, ayant un contour rampe, les dérivées
premières elles-mêmes sont d'un intérêt limité car la pente maximale a peu de chances de se trouver
sur l'une des deux directions considérées

Figure 8 Filtres de Robert


Figure 9 Filtrage par Robert

3.1.2 L’opérateur Prewitt:


La matrice qui correspond au filtrage horizontal, faisant ressortir essentiellement les contours
verticaux, selon l'opérateur de Prewitt, s'écrit hx = [-1 0 1] tandis que la matrice verticale hy est sa
transposée. Les deux convolutions avec le tableau de valeurs initiales créent deux tableaux Gx et
Gy à l'origine du tableau G sur lequel on peut localiser les maximums.

Figure 10 Filtre de Prewit

3.1.3 L’opérateur Sobel :


L'opérateur utilise des matrices de convolution. La matrice (généralement de taille 3×3) subit une
convolution avec l'image pour calculer des approximations des dérivées horizontale et verticale. Soit
A l'image source, Gx et Gy deux images qui en chaque point contiennent des approximations
respectivement de la dérivée horizontale et verticale de chaque point. Ces images sont calculées
comme suit:
Figure 11 Filtrage Sobel

3.2 Filtrage des images :


Un signal numérique est une suite de nombres, obtenue par exemple par échantillonnage d'un signal
analogique. Une fréquence d'échantillonnage est généralement associée au signal numérique. Le filtrage
numérique est un traitement effectué sur cette suite de nombres, pour transformer le signal. Ce calcul
peut être fait sur un ordinateur à partir de signaux stockés en mémoire. Dans les circuits d'électronique
numérique, il est fait en temps réel par des microprocesseurs spécialisés (DSP Digital Signal Processor),
que l'on rencontre par exemple dans les téléphones portables pour le traitement du son. Nous allons
aborder ici un type particulier de filtrage, le filtrage par convolution. Les filtres obtenus sont à réponse
impulsionnelle finie (filtre RIF). Les images numérisées sont aussi des signaux numériques, mais à deux
dimensions. Une image numérisée est donc une matrice de nombres. Le filtrage par convolution se
pratique couramment sur les images numériques, par exemple pour rendre les images légèrement floues
afin de réduire le bruit, ou bien au contraire pour accentuer les détails. Nous verrons comment se fait le
filtrage par convolution sur une image.

3.2.1 La convolution numérique :


Les images numériques sont des signaux numériques à deux dimensions, qui s'apparentent aux signaux
de taille fixe discutés plus haut. Les échantillons sont appelés les pixels. Le filtrage par convolution se
fait sur une image en niveaux de gris. Les images en couleur sont composées de trois couches, par
exemple rouge, vert et bleu. Chaque couche peut être vue comme une image en niveau de gris. Il faudra
donc opérer sur chaque couche séparément pour filtrer une image en couleur (pas nécessairement avec
le même filtre). On considère une image numérique en niveaux de gris, dont la valeur du pixel (i,j) est
notée Xi,j. On adopte la convention qui consiste à placer l'indice de colonne (indice i) en premier, car cet
indice correspond à l'axe x sur l'image. La réponse impulsionnelle (ou noyau) dans le cas d'un signal
numérique à deux dimensions est elle-même un signal à deux dimensions, c'est-à-dire une matrice, dont
les coefficients seront notés hm,n. Pour simplifier, on se limite au cas des réponses impulsionnelles
carrées, avec un nombre de termes impair sur chaque dimension M=2P+1. Par exemple, pour P=1 :
L'image filtrée Y s'obtient en effectuant
le produit de convolution entre X et H, ce
qui donne pour un pixel (i,j) de l'image finale :

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.

Figure 12 La convolution numérique

3.2.2 Filtre passe-haut : « Accentuation »


Un filtre passe-haut favorise les hautes fréquences spatiales, comme les détails, et de ce fait, il
améliore le contraste. Un filtre passe haut est caractérisé par un noyau comportant des valeurs
négatives autour du pixel central.

Figure 13 Filtre passe haut

3.2.3 Filtre passe-bas : « Lissage »


Les filtres passe-bas agissent au sens inverse des filtres passe-haut, le résultat est un adoucissement
des détails, ainsi qu’une réduction du bruit granuleux.

Figure 14 Filtre passe bas d'une image

4 Histogramme & Binarisation :


4.1 L’histogramme des images :
En imagerie numérique, l’histogramme représente la distribution des intensités (ou des couleurs) de
l'image. C'est un outil fondamental du traitement d'images, avec de très nombreuses applications. Les
histogrammes sont aussi très utilisés en photographie et pour la retouche d'images.
Figure 15 Histogramme de l'image

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

4.1.1 Egalisation d’histogrammes :


L'égalisation d'histogramme est une méthode d'ajustement du contraste d'une image qui utilise
l'histogramme. Elle consiste à appliquer une transformation sur chaque pixel de l'image, et donc
d'obtenir une nouvelle image à partir d'une opération indépendante sur chacun des pixels. Cette
transformation est construite à partir de l'histogramme cumulé de l'image de départ. L'égalisation
d'histogramme permet de mieux répartir les intensités sur l'ensemble de la plage de valeurs possibles
(0 à 255 en général pour des images 8 bits), en « étalant » l'histogramme. Théoriquement (cas
continu) l'histogramme devrait même être plat (loi uniforme continue). Toutefois à cause de la
discrétisation, ceci est rarement le cas. L'égalisation est intéressante pour les images dont la totalité,
ou seulement une partie, est de faible contraste (pixels d'intensité proches). La méthode est rapide,
facile d'implémentation, et complètement automatique (i.e. pas de réglages).

Figure 17 Egalisation d'histogrammes

4.1.2 Rehaussement des images :


L'égalisation d'histogramme, qu'il soit global, ou appliqué de manière locale, est un outil très utilisé
pour l'amélioration du contraste, et donc le rehaussement. De même, la spécification d'histogramme
peut être utilisée pour le rehaussement. Il est également possible d'utiliser les statistiques de
l'histogramme (moyenne, variance) pour l'amélioration de l'intensité et du contraste

4.2 La binarisation ou le seuillage :


Figure 18 Rehaussement des images

Le seuillage d'image est une technique simple


de binarisation d'image, elle consiste à
transformer une image en niveau de gris en une
image dont les valeurs de pixels ne peuvent
avoir que la valeur 1 ou 0. On parle alors
d'une image binaire ou image en noir et blanc.
Le seuillage d'image remplace un à un les pixels d'une image à l'aide d'une valeur seuil fixée (par
exemple {\displaystyle s=123}s=123). Ainsi, si un pixel a une valeur supérieure ou égale au seuil (par
exemple 150), il prendra la valeur 255 (blanc), et si sa valeur est inférieure (par exemple 100), il
prendra la valeur 0 (noir).
Figure 19 Seuillage des images
TP1
Vecteurs, Matrices,
Histogramme & Binarisation
5 Vecteurs & Matrices :
En fait, toute variable de Matlab est une matrice (Scalaire : matrice 1x1, vecteur : matrice 1xN ou Nx1).
On peut spécifier directement une matrice sous la forme d’un tableau, l’espace ou la virgule sépare deux
éléments d’une même ligne, les points virgules séparent les éléments de lignes distinctes.
Code :
>> A = [-1 -1 -1; -1 -9 -1; -1 -1 -1]
Exécution :

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 :

« One » peut changer la valeur d’un élément de la matrice par l’affectation


Code :
>> A (2,2) = 9
Exécution :

On peut avoir des informations sur la taille d’une matrice :


Code :
>> size(A)
Exécution :
On peut afficher le graphe fréquentiel de la matrice :
Code :
>> freqz2(A)
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.

Les niveaux de gris :


Code:
>> I=ones(4,1);
>> In=I*[(0:6)/6]
Exécution:

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:

On divise les niveaux de gris par 16 niveaux:


Code:
>> In=I*[(0:16)/16]
Exécution:

Pour afficher l’image I et l’image In (niveaux de gris) :


Code:
>> subplot(221);
>> imshow(I);
>> subplot(222);
>> imshow(In)
Exécution:
7 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.

Affichage de l’image ‘CAMERAMAN’


Code:
>> I= imread('cameraman.tif');
>> imshow(I)
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');