TP – Transformations ponctuelles d'images

Ce TP a pour but de vous faire réaliser des transformations ponctuelles d'images.

A l'URL [Link] vous trouverez des images (et plus).

Plan :

1. Création d'une LUT (image monochrome).............................................................................1

Bases.......................................................................................................................................1
LUT d'une image en niveaux de gris......................................................................................2
2. Histogramme...........................................................................................................................3
Comparaison...........................................................................................................................3
Egalisation d'histogrammes.....................................................................................................3
Binarisation.............................................................................................................................3

1. Création d'une LUT (image monochrome)

Bases

Pour l’affichage d’une image monochrome Matlab utilise une LUT par défaut qui associe à
chaque élément de la matrice image une couleur. Cette LUT par défaut présente 64 couleurs
différentes en sortie (la commande colormap affiche les niveaux de la LUT par défaut).

Par exemple pour un écran CRT :

Soit i l'index de la LUT par défaut. A chaque i correspond une couleur créée par la
combinaison ri, vi et bi des couleurs primaires RVB. Ces valeurs ri, vi et bi sont utilisées par un
convertisseur numérique analogique (CNA) de façon à venir exciter les canons Rouge, Vert,
et Bleu de l’écran. On obtient alors à l’affichage une couleur créée par la synthèse additive de
trois couleurs primaires. Sous Matlab, il est possible de créer ses propres LUT puis de les

appliquer à l’aide de la fonction colormap. Les valeurs doivent cependant être normalisées sur
l’intervalle [0, 1]. Prenons par exemple le cas simple d’une matrice M de taille 3x3 :

1/4 [Link]@[Link]
 5 5 1

[ ]
M= 1 2 2
3 3 5

Cette matrice comprend 4 valeurs distinctes. On se propose d’afficher : « 1 » en noir, « 2 » en

blanc, « 3 » en rouge, et « 5 » en vert. Pour cela on crée la LUT map4C dont les sorties sont
les 4 couleurs souhaitées :

% Création matrice
M=[5 5 1;1 2 2;3 3 5] ;
% Définition de la LUT
r=[0 1 1 0];
v=[0 1 0 1];
b=[0 1 0 0];
map4C=[r’ v’ b’];
% Affichage
colormap(map4C);
image(M);

Remarques :
● Matlab ne permet pas de définir de LUT pour les images couleurs (il n’est pas possible
de visualiser une image couleur en créant une LUT pour chacun des plans RVB).
● Matlab propose un ensemble de LUT prédéfinies (voir la rubrique « Supported
Colormaps » de l’aide de la commande colormap).

LUT d'une image en niveaux de gris

Pour afficher une image monochrome en niveau de gris, il faut donc utiliser une LUT dont les
couleurs en sortie ne sont que des nuances de gris. Dans ce cas : ∀ i∈[0, 255]: r i=v i=bi
(cas général de la valeur de luminance d’un pixel codée sur 8 bits, soit 256 niveaux
d'intensité).

Exercice 1 :

En vous inspirant des exemple précédents, synthétisez la LUT réalisant l'inversion vidéo d'une
image monochrome. Ce traitement consiste à réaliser le « négatif » de chaque plan de
couleurs i.e. le niveau 0 devient 255 et inversement, le niveau 1 devient 254, ... etc

Chargez (imread) l'image [Link], et affichez ( ) son négatif. La LUT à créer est :
image

% Création de la LUT
r=1:-1/255:0;
v=1:-1/255:0;
b=1:-1/255:0;
lut=[r' v' b'];

LUT que vous appelez avec la commande colormap( lut ).

Exercice 2 :

Synthétisez la LUT d'une image monochrome (de profondeur 8 bpp) telle que :

2/4 [Link]@[Link]
 ● les NDG (Niveaux de Gris) inférieurs à 50 soient affichés en rouge,
● les NDG supérieurs à 150 soient affichés en vert,
● les autres inchangés.

2. Histogramme
Comparaison

La commande imhist permet de calculer et d'afficher l'histogramme d'une image monochrome

(pour une image couleur il faut procéder plan par plan).

Chargez (imread) les 2 images [Link] et [Link], puis à l'aide de imhist visualisez et
comparez leurs histogrammes. Pensez notamment à reconnaître dans chacun des
histogrammes les modes principaux (c.a.d les « pics ») et les régions associées dans les
images d'origine.

Chargez et ouvrez l'image couleur [Link]. Utilisez imhist et visualisez séparément les 3
histogrammes des plans RGB de l'image.

Egalisation d'histogrammes

Exercice :

Il s'agit d'effectuer l'égalisation d'histogramme à l'aide de la fonction histeq. Votre script doit
réaliser :
● le chargement (imread) de l'image [Link],
● le calcul de son histogramme (imhist),
● son égalisation (histeq),
● l'affichage des 2 images (imshow) et de leurs histogrammes (imhist) respectifs.

Comparez les images et les histogrammes obtenues.

Binarisation

Nous voulons binariser une image monochrome. La méthode sera basée sur un seuillage brut,
c.a.d que si un pixel a une intensité supérieure au seuil, il lui est attribué la couleur blanche (à
« 1 »), sinon il sera noir (mis à « 0 »). L'image obtenue après traitement ne comporte donc que
2 niveaux.

Exercice 1 :

Commencez par charger (imread) l'image [Link] et affichez la (imshow) ainsi que son
histogramme (imhist).
A partir de cet histogramme déterminez un seuil de binarisation. Choisissez ce dernier de
façon classique comme la valeur de NDG médiane entre 2 modes (mais ce seuil pourrait être
choisi différemment : valeur moyenne de l’intensité sur l’ensemble de l’histogramme, ... etc).

3/4 [Link]@[Link]
Enfin utilisez la fonction im2bw afin de seuiller et générer directement l'image binaire que
vous afficherez (imshow). Le seuil fourni comme argument à im2bw doit être normalisé sur
[0,1] (par exemple 128 normalisé devient 128/255).

Exercice 2 :

On se propose maintenant de créer l’image binaire de [Link] sans utiliser la fonction

im2bw. Créez un script de seuillage et de binarisation. Le but est de balayer l’ensemble des
pixels de l’image et de vérifier s’ils sont chacun inférieurs ou supérieurs au seuil choisi.

Vous pouvez utiliser des instructions classiques (if, for), mais comme Matlab est un langage
interprété, il est préférable de travailler en vectoriel afin d'éviter les (coûteuses) boucles
imbriquées. La commande find est alors très utile car elle permet de trouver directement au
sein de la matrice image, les index des pixels satisfaisant un critère.

Un exemple :

% Chargement de l'image
im = imread('[Link]');
% Fixation du seuil
seuil = 128 ;
% RAZ des pixels inférieurs au seuil
imBinaire = ones( [ size(im) ] );
imBinaire( find( im < seuil ) ) = 0;

Remarque :

On peut faire encore plus efficace sachant qu'un masque logique est directement créé à partir
du critère (si vrai, le pixel du masque est mis à « 1 », à zéro sinon). Exemple :

% Chargement de l'image
im = imread('[Link]');
% Fixation du seuil
seuil = 128 ;
% Création du masque logique
imBinaire = im > seuil;

4/4 [Link]@[Link]