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