Traitement d’images médicales TP_FPGA

Manipulation d’image sur FPGA

Présentation
I. Objectif
L’objectif du TP est l’initiation à la manipulation et la programmation d’une carte FPGA pour
le traitement d’image. On s’intéresse à l’enregistrement d’une image dans une mémoire ROM
créé par IP dans le FPGA ; ensuite on applique sur l’image enregistrée un traitement par
programmation VHDL.

II. Montage à réaliser

L’image, contenant l’objet à détecter, est préenregistrée dans le FPGA en utilisant une
mémoire ROM sous forme d’IP. Si l’objet est détecté dans l’image on affiche (allume) une
LED.

Rst Erosion /
Lecture Masque dilatation

R
Mémoire (Image) Conversion Binarisation

Affichage
Clk

III. Détection d’objets

La détection basée sur l’intensité est une méthode simple et rapide qui peut être utilisée dans
plusieurs systèmes de vision artificielle, elle peut être exploitée pour la détection des objets
d’intérêt dans une image médicale.
Cette méthode vise à détecter des points et/ou régions de l’image qui diffèrent des propriétés
par rapport aux entourages (l’intensité ou la couleur...). L’idée générale est de chercher les
régions d’une image numérique dans laquelle certaines propriétés sont constantes ou varient
dans une plage de valeurs donnée.
Traitement d’images médicales TP_FPGA

IV. Étapes de l’algorithme

1. Conversion
On doit convertir l'image du RGB en HSV (Hue, Saturation, Value). En effet, la représentation
en HSV nous permettra de se baser sur un canal ou deux : la teinte et la saturation de la couleur,
sans prendre en compte la brillance (V), ce qui permettra d'éliminer les problèmes liés à
l'éclairage. Dans notre cas on ne va pas faire cette étape de conversion, il suffit d’extraire la
composante R dans laquelle on considère que nous avons notre zone d’intérêt.
2. Binarisation
La binarisation consiste à placer les pixels de l'image dans deux classes distinctes :
généralement représentées par le blanc et le noir. La première classe correspondra à la couleur
à isoler, la seconde à toutes les autres couleurs. Ainsi, si la couleur de l'objet sélectionné est le
rouge, nous verrons sur notre image binarisée tous les éléments rouges apparaître en blanc sur
un fond noir.
3. Le Masque
Créer un masque pour sélectionner les pixels qui peuvent appartenir à l'objet en se basant
uniquement sur la composante sélectionnée.
Théoriquement, nous devons mettre en blanc tous les pixels ayant les mêmes valeurs que notre
couleur. Pratiquement, le résultat ne serait pas très convaincant et nous ne récupérerions que
quelques pixels.
Il faut rechercher les pixels qui se situent dans un intervalle autour de cette couleur, nous
utiliserons alors une valeur de tolérance. Nous cherchons donc les pixels qui vérifient :
𝑅 − 𝑡𝑜𝑙𝑒𝑟𝑎𝑛𝑐𝑒 ≤ 𝑅𝑝𝑖𝑥𝑒𝑙 < 𝑅 + 𝑡𝑜𝑙𝑒𝑟𝑎𝑛𝑐𝑒

4. Opérateurs morphologiques et isolation de l'objet

L’image en noir et blanc nous indique où se trouve la couleur de notre objet dans l'image par
des taches blanches. Mais il va falloir l’isoler des couleurs similaire dans l'environnement.
Globalement l’objet correspondra à la tache la plus grosse et la plus dense. Il nous faut donc
nous débarrasser de ces pixels éparpillés qui ne représentent pas l’objet.
On applique successivement deux opérateurs morphologiques :
 D’abord nous effectuons une érosion. Cela nous permet de supprimer les pixels isolés
qui ne correspondent pas à notre objet de couleur.
 Ensuite nous effectuons une dilatation qui nous permet de renforcer les groupes denses
de pixels (donc notre objet)
Traitement d’images médicales TP_FPGA

Implémentation

I. Conversion, Binarisation & Masque

Les trois blocs (Conversion, Binarisation et Masque) seront écrits dans le même fichier
VHDL. La conversion consiste tout simplement à sélectionner les 3 bits de poids faible des
pixels à la sortie de la mémoire pour construire la composante R. La binaristion et le masque
constituent un seuillage selon la règle suivante :
 Si 4<R alors sortie = 1
 Sinon sortie = 0.
Le programme suivant réalise ces blocs.

library IEEE;

use IEEE.STD_LOGIC_1164.ALL;

entity conv_binar is

Port ( pixel : in STD_LOGIC_VECTOR (7 downto 0);

led : out STD_LOGIC);

end conv_binar;

architecture Behavioral of conv_binar is

signal R : STD_LOGIC_VECTOR (2 downto 0);

begin

R <= pixel(2 downto 0);

led <= '1' when R>"100"

else '0';

end Behavioral;

Tester le programme sur FPGA en considérant l’entrée 8 bits issue de switches et la sortie
commande une LED. Pour cela créer le fichier des contraintes d’implémentation en
considérant les correspondances suivantes :
NET "pixel<0>" LOC = "G18" ;
NET "pixel<1>" LOC = "H18" ;
NET "pixel<2>" LOC = "K18" ;
NET "pixel<3>" LOC = "K17" ;
NET "pixel<4>" LOC = "L14" ;
NET "pixel<5>" LOC = "L13" ;
NET "pixel<6>" LOC = "N17" ;
NET "pixel<7>" LOC = "R17" ;
NET "led" LOC = "J14";
Traitement d’images médicales TP_FPGA

II. Utilisation des IP (Intellectual Propriety)

1. Création d’un IP Mémoire contenant l’image

Création du fichier valeur.coe sous Matlab

La carte FPGA étant limitée, on doit mettra en forme les images pour réduire l’espace occupé
par chaque pixel. Ainsi une image de couleur de 24bits/pixel doit être réduite à uniquement 8
bits/pixel.
Les pixels transformés doivent être mis dans un fichier "valeur.coe" en utilisant un
programme Matlab.
Le fichier "valeur.coe" compatible avec les cartes FPGA de chez Xilinx est un fichier text qui
a la forme suivante :

memory_initialization_radix=2;

memory_initialization_vector=

val_1,
val_2,
...
Val_n;

Le programme ci-après permet de créer ce fichier en transformant une image 24bits en une
image 3bits.
a. Expliquer les étapes du programme suivant.
b. Appliquer le programme sur une image médicale d’au plus de 200x200.

x = imread('image.jpg');
figure(1),imshow(x);
y = zeros(size(x));
x=double(x) ;
y(:,:,1) = x(:,:,1) /32 ;
y(:,:,2) = (x(:,:,2) /32)*8;
y(:,:,3) = (x(:,:,3) /64)*64;
y=uint8(y);
z = y(:,:,1) + y(:,:,2) + y(:,:,3) ;
z = z(:);

fid = fopen('valeurs.coe', 'wt');

fprintf(fid, sprintf('memory_initialization_radix=2;\n\n'));
fprintf(fid, sprintf('memory_initialization_vector=\n\n'));

for i = 1:length(z)-1
fprintf(fid, sprintf('%-08s,\n',dec2bin(z(i))));
end
i = length(z);
fprintf(fid, sprintf('%-08s;\n',dec2bin(z(i))));

fclose(fid);
Traitement d’images médicales TP_FPGA

Implémentation de la mémoire

On veut créer une mémoire ROM pour y mettre les coefficients de notre image. Pour cela
lancer l’environnement ISE de Xilinx.
Le FPGA disponible au Labo est un Spartan dont les caractéristiques sont les suivantes :
 Spartan3E
 XC3S500E
 FG320
Créer un projet et suivre les étapes ci-après.
 Sélectionner dans « New Source » l’ajout d’un « IP »

 Sélectionner dans « RAM&ROM » le générateur de mémoire « Block Memory

Generator »
 Next puis finish

 Sélectionner « Single Port ROM »

 Puis « Next »
Traitement d’images médicales TP_FPGA

 On créera une mémoire de 8 x 40 000

 « Next » à l’étape 3, sélectionner, dans Load File, le fichier « valeur.coe »
 Puis « Next » jusqu’à l’étape 5, choisir « Generate »

2. Lecture de l’image
Le bloc "Lecture" permet de fournir les adresses nécessaires pour parcourir la mémoire. Ainsi,
les pixels seront transmis séquentiellement au bloc "Conversion".
En utilisant un IP, créer un compteur pour fournir les adresse de la mémoire.

III. Erosion/Dilatation et Affichage

Pendant un cycle de lecture de l’image, le bloc Affichage doit compter le nombre Np de pixels
dont la composante rouge dépasse le seuil. Si Np est supérieur à 10 000 alors on envoie 1,
sinon on envoie 0.
a. Proposer un programme pour réaliser le bloc Affichage.
b. Ecrire un fichier VHDL pour compléter le montage (sans le bloc érosion-dilation).
Tester le montage pratiquement
c. Donner une solution pour réaliser le bloc érosion-dilation.