Gabriel ARNAUD Lucie KROL VEL FARMAS Alex DRUGEON
Projet E5FE Traitement d’image
2016/2017
Rapport projet traitement d’image Gabriel A. – Lucie KVF. – Alex D.
2
Table des matières I) Préparation ...................................................................................................................................... 3
II) Implantation du traitement ............................................................................................................. 4
1. Filtre médian ............................................................................................................................... 5
2. Filtre de Sobel .............................................................................................................................. 7
III) Optimisation du traitement ...................................................................................................... 10
Annexe : Code complet ......................................................................................................................... 11
Rapport projet traitement d’image Gabriel A. – Lucie KVF. – Alex D.
3
Objectif : Ce TP a pour but la réalisation de deux opérateurs de traitement vidéo, les filtres médian et
de Sobel afin de réaliser une détection de contour, dont les caractéristiques sont détaillées ci-après.
I) Préparation
Le projet est développé sur PC Linux ainsi que sur la plateforme de développement de NXP MCIMX6Q-
SL.
Notre PC a les caractéristiques suivantes :
- Processeur I3 4 cœurs à 3,3 Ghz
- 4 Go de mémoire vive
La carte MCIMX6Q-SL implémente le design Freescale SABRE Lite. Ce design comporte un ensemble
de ressources périphériques montées autour d’un cœur i.MX6 Q, composé de 4 cœurs ARM Quad
Cortex-A9 MPCore™ cadencés à 1 GHz. Chaque cœur a son propre watchdog et timer, et possède deux
mémoires caches (un cache instruction L1 de 32kB et un cache de données L1 de 32kB également) ainsi
qu’un co-processeur Cortex-A9 NEON.
Une autre couche mémoire cache L2 de 1 MB est partagée avec tous les cœurs.
Pour continuer sur les mémoires intégrées, on trouve sur la carte SABRE Lite :
- 96KB de ROM pour le boot
- 256KB de RAM à accès rapide dédiée à la communication multimédia interne
- 16KB de mémoire RAM sécurisée
La carte comprend de très nombreuses interfaces et fonctions : CAN, audio (sortie + micro IN), SPI,
JTAG, camera, RS232, I²C, LVDS, MIPI, PCIe, une interface Android dédiée, des LEDs et des switches.
Rapport projet traitement d’image Gabriel A. – Lucie KVF. – Alex D.
4
Bloc diagramme de la carte SABRE Lite
Nous utiliserons le port HDMI, Ethernet et USB, ainsi que l’alimentation 5V/4A externe. L’OS utilisé est
une distribution Linux 3.0.15
Les images envoyées par la caméra fournie ont une définition de 640*480 pixel (ratio 4 :3) à une
cadence de 30 images par seconde. Chaque image comporte donc 640x480 = 307 200 pixels : en 1
seconde, il faut donc traiter 30*307 200 = 9 216 000 pixels.
II) Implantation du traitement
Le projet est codé en C++ en utilisant les fonctions de la librairie OpenCV.
La base d’acquisition/restitution du flux vidéo de la caméra ainsi que la conversion d’une image niveau
de gris est fournie en début de projet.
La chaîne de traitement complète et qui servira d’architecture à notre code est la suivante :
Chaine de traitement pour une détection de contour d’une image
Entrée
image
Conversion
en niveaux
de gris
Filtre
médian
Filtre de
Sobel
Affichage Affichage Affichage
Affichage
Rapport projet traitement d’image Gabriel A. – Lucie KVF. – Alex D.
5
1. Filtre médian
Ce filtre repose sur le calcul de la valeur médiane de la répartition des niveaux de gris des pixels qui
l’entoure, 8 dans notre cas. Ce filtre est appliqué pixel par pixel, et l’élément structurant (nous
prendrons uniquement des matrices 3x3 par simplification). Il permet l’élimination efficace de l’effet
poivre et sel, comme le montre l’exemple suivant :
Principe du filtre médian
La valeur erratique (ici 150, qui est très clairement au-dessus des valeurs environnantes) est rejetée à
l’extrémité de la série. Cela suppose que les pixels par zone ont globalement les mêmes niveaux de
gris. D’autre part, ce procédé préserve les contours.
Les calculs sont effectués à chaque fois pour chaque pixel dans deux boucles for imbriquées, un pixel
étant repéré par rapport à ses voisins comme suit :
I𝑖−1,𝑗−1 I𝑖−1,𝑗 I𝑖−1,𝑗+1
I𝑖,𝑗−1 I𝑖,𝑗 I𝑖,𝑗+1
I𝑖+1,𝑗−1 I𝑖+1,𝑗 I𝑖−1,𝑗+1
Matrice pour le calcul du filtre median
Nous trions les valeurs des pixels, sélectionnons la médiane et l’attribuons au pixel traité (i,j).
Nous avions tout d’abord testé un simple tri à bulle de tableau mais nous avons remarqué après un
test en rajoutant un bruit de type Poivre & Sel (Code en annexe) qu’il ne fonctionnait pas
correctement.
Rapport projet traitement d’image Gabriel A. – Lucie KVF. – Alex D.
6
Simple tri à bulle
Nous avons alors décidé d’utiliser les fonctions vector et sort, cette dernière permettant d’optimiser
le calcul (Code en annexe).
Nous obtenons le résultat suivant :
Résultat filtre médian sur une image niveau de gris avec effet poivre & sel
La fonction poivre & sel se trouve en annexe, de plus l’utilisateur peut choisir la taille des ‘grains’
pour tester les limites du filtre médian, cette fonction de trouvant au début du code en annexe.
Rapport projet traitement d’image Gabriel A. – Lucie KVF. – Alex D.
7
2. Filtre de Sobel
Le filtre de Sobel permet une détection des contours d’une image. Appliqué sur une image en niveaux
de gris, nous obtiendrons une image noire, avec les contours des éléments en blanc.
Ce filtre peut traiter une image selon divers axes :
Masques de travail pour un traitement par filtre de Sobel
Nous appliquerons uniquement les matrices horizontale (Sobel 90°) et verticale (Sobel 0°).
Le procédé suivi dans l’approche contour appliqué à une image en niveaux de gris est le suivant :
Chaine de traitement pour le filtre de Sobel
Le calcul du gradient se fait comme suit :
Calcul de Gx
Rapport projet traitement d’image Gabriel A. – Lucie KVF. – Alex D.
8
Data_med correspond à l’image issue du traitement par le filtre médian, associé à son pas de parcours
step_med. On retrouve ici en facteur de chaque valeur de Data_med les coefficients de la matrice de
travail.
Le code pour l’élément vertical suit le même procédé.
Les deux traitements sont conditionnés par une série de vérifications pour traiter les effets de bord,
par recopie de la ligne/colonne limite à l’indice inférieur/supérieur selon le pixel traité (code annoté
en annexe).
A chaque fois après le calcul des deux composantes du pixel (Data_sob_Gx et Data_sob_Gy), il faut
normaliser les valeurs obtenues sur 8 bits et effectuer le seuillage :
Seuillage et normalisation du filtre de Sobel
Le même calcul est effectué pour le gradient Gy.
Enfin, il faut fusionner les deux composantes pour générer l’image finale Data_sob. Nous avons deux
méthodes à disposition :
o Module du gradient G = √GX2 + GY
2
o Distance avec les valeurs absolues G = |𝐺𝑋| + |𝐺𝑌|
Nous avons par la suite conservé la seconde méthode, qui est la plus optimisée pour le calcul.
Rapport projet traitement d’image Gabriel A. – Lucie KVF. – Alex D.
9
Nous obtenons les résultats suivants pour la chaine complète depuis l’image niveau de gris jusqu’à la
détection de contour :
Image niveau de gris et image avec effet poivre et sel
Image avec effet poivre et sel et résultat du filtre médian
Traitement par filtre de Sobel : Gx, Gy puis total
Rapport projet traitement d’image Gabriel A. – Lucie KVF. – Alex D.
10
III) Optimisation du traitement
En se basant sur les dernières versions fonctionnelles, nous avons utilisé l’outil GProf, qui
permet d’analyser le temps d’exécution par fonction, et de savoir quelle a été la fonction
la plus coûteuse en temps. Les mesures ont été prises sur un échantillon de 30 images à
chaque fois, contrôlé par la variable cpt, dont la valeur est en condition de la boucle
while de traitement (cf : code en annexe).
Les optimisations ont été menées sur le filtre de Sobel principalement, en supprimant les
multiplications par 0 qui avaient été laissée au début du développement, en regroupant
les deux calculs de Gx et Gy dans la même boucle for et en utilisant une seule variable de
calcul Gtmp pour Gx et Gy dans chaque cas. Auparavant, nous réattribuions la valeur
data_sob_Gx ou data_sob_Gy à chaque calcul.
Voici le temps d’exécution moyen de la fonction FiltreSobel :
Et le temps d’exécution moyen total :
La fonction FiltreMedian a un temps d’exécution moyen avoisinant les 1,82 secondes
pour toutes les versions
4,00
4,20
4,40
4,60
4,80
5,00
5,20
5,40
5,60
5,80
6,00
V3.2 V3.3 V3.4
Temps d'exécution moyen de filtreSobel
7,80
8,00
8,20
8,40
8,60
8,80
9,00
0 0,5 1 1,5 2 2,5 3 3,5
Temps d'exécution moyen total=f(version)
Rapport projet traitement d’image Gabriel A. – Lucie KVF. – Alex D.
11
Annexe : Code complet
• Fonction main : initialisation
Rapport projet traitement d’image Gabriel A. – Lucie KVF. – Alex D.
12
Rapport projet traitement d’image Gabriel A. – Lucie KVF. – Alex D.
13
• Fonction main : boucle while pour le traitement
Rapport projet traitement d’image Gabriel A. – Lucie KVF. – Alex D.
14
• Filtre médian
Rapport projet traitement d’image Gabriel A. – Lucie KVF. – Alex D.
15
• Filtre de Sobel
Rapport projet traitement d’image Gabriel A. – Lucie KVF. – Alex D.
16