1 :title: Algorithmes rapides sur GPU
5 # boite arrondie fond gris
22 * - * kjh kj hkjh kqj hdkq jdhq lkj lj lkj lkj lj lqks,jxdxqdiqoioqiij
23 * jkkjskdjf lskfj lskfjlksdjfls
24 - .. image:: css/logo-femto.png
32 TRAITEMENT D'IMAGES SUR GPU
33 ===========================
35 Algorithmes rapides pour le filtrage et la segmentation des images bruitées sur GPU.
36 ------------------------------------------------------------------------------------------------
41 Université de Franche-Comté, Institut FEMTO-ST
42 +++++++++++++++++++++++++++++++++++++++++++++++
43 Département DISC - équipe AND
44 +++++++++++++++++++++++++++++
45 Direction : R. Couturier & S. Domas
46 ++++++++++++++++++++++++++++++++++++
50 PLAN DE LA PRÉSENTATION
51 =======================
53 #. Introduction - cadre des travaux
55 - Les GPUs (Graphical Processing Units)
56 - Généralités sur le traitement d'image. Nos axes de recherche.
58 #. La segmentation des images
60 - Généralités. Travaux de référence.
61 - Parallélisation GPU d'un algorithme de segmentation de type *snake*.
63 #. Le filtrage des images
65 - Généralités. Travaux de référence.
66 - Optimisation pour GPU des filtres médian et de convolution.
67 - Conception d'un algorithme parallèle de réduction de bruit par recherche des lignes de niveaux.
69 #. Synthèse et conclusion.
75 Les GPUs - Les traitements d'image
81 Les GPUs ou *Processeurs graphiques*.
82 -------------------------------------
84 .. image:: img/gpucpu1.png
88 * Processeurs *classiques* **CPU** : exécution **séquentielle**
90 - Quelques unités de calcul ( les c |oe| urs).
92 * Processeurs *graphiques* **GPU** : exécution **massivement parallèle**
94 - Des centaines, voire millier, d'unités de calcul, regroupées en quelques SMs (*Streaming Multiprocessors*).
98 * La multiplication des c |oe| urs dans les GPUs se fait au détriment des fonctions de contrôle et de cache.
99 * Seule la mémoire *globale* est accessible par l'ensemble des fils d'exécution (les *threads*) et ses performances sont faibles.
100 * AU sein de la RAM il y a différents canaux vers différents types de mémoires.
101 * L'accès efficace aux mémoires est contraignant.
102 * Les échanges de données entre le GPU et son hôte CPU sont pénalisants.
103 * Il est important de concevoir un partage équilibré des ressources au sein de chaque SM, pour permettre un niveau de parallélisme élevé, et donc d'envisager de bonnes performances.
104 * La mise au point n'est pas aisée lorsque des centaines de milliers de threads concourent à l'exécution d'une tâche.
111 Le traitement des images
112 ------------------------
114 * L'accroissement des capacités de calcul a suivi l'augmentation des résolutions d'images.
115 * Les traitements envisagés sur les images sont de plus en plus évolués ( traitements de haut niveau ) et requièrent souvent un temps de calcul accru.
116 * L'architecture parallèle particulière des GPUs a permis d'améliorer considérablement les performances de certaines classes d'algorithme et fait espérer par ailleurs des accélérations importantes.
121 * La croissance des capacités de calcul des GPUs à été beaucoup plus forte que celle des CPUs.
122 * **Les travaux présentés ici sont une contribution à cette recherche de performance.**
128 Le traitement des images
129 ------------------------
131 * Beaucoup d'applications intègrent des traitements d'images numériques.
132 * Les capteurs numériques et les conditions d'acquisition sont à l'origine de perturbations (bruits).
133 * Les hautes résolutions sont souvent obtenues à faible flux de photons, dont les variations engendrent du bruit.
134 * La segmentation représente aussi un enjeu crucial, mais aucun algorithme universel n'a encore été élaboré.
138 * les bruits dégradent l'image de la scène idéale et peuvent en fausser ou compliquer l'interprétation.
139 * on recense plus de 4000 algorithmes de segmentation
140 * La segmentation intervient dans beaucoup d'applications : du tracking à la détection ou à l'extraction de caractéristiques diverses.
141 * Mais aujourd'hui encore, une bonne segmentation est celle qui permet d'extraire ce que l'on attend => l'algorithme dépend du problème.
147 Traitements d'images de haut niveau
148 -----------------------------------
150 #. **Pré-traiter** et effectuer les traitements de haut niveau sur des images *améliorées*.
152 * réduction, *a priori*, du coût des traitements de haut niveau.
153 * les prétraitements ont eux aussi un coût, en temps de calcul et potentiellement en information.
155 #. **Ne pas pré-traiter** et effectuer les traitements de haut niveau sur les images bruitées.
157 * pas de perte d'information due au pré-traitement.
158 * les traitements de haut niveau sont, *a priori*, plus coûteux.
163 * Certains algo (LNIV) peuvent être considérés comme pré-traitement ou comme haut-niveau selon le point de vue et la classe d'algorithme.
170 Axes des travaux présentés
171 --------------------------
174 **Segmentation : accélérer le traitement de haut niveau**
176 * La segmentation consiste à identifier des zones homogènes dans une image.
177 * Algorithme de segmentation d'images bruitées par contours actifs, de la classe des *snakes*.
178 * Conception d'une implémentation avec adaptation de la technique d'optimisation.
180 **Filtrage : accélérer les pré-traitements**
182 Réduction de bruit additif gaussien, suivant deux méthodes de conception :
184 * algorithme original, conçu spécifiquement pour GPU, conjointement à son implémentation.
185 * algorithmes existants, où l'effort de conception ne peut porter que sur l'implémentation : filtres médian et de convolution.
196 * Nous nous sommes focalisés sur les *images naturelles* :
198 - réalisées en lumière naturelle, en intérieur ou en extérieur,
199 - prises avec un dispositif standard (CMOS, CCD).
201 * Les traitements que nous présentons ici opèrent sur des images en
202 niveau de gris (8 ou 16 bits).
206 * Toutefois, la plupart des algorithmes que nous proposons s'étend simplement à d'autres types d'images, comme les images en couleur ou celles issues des imageries ultrasonore ou RADAR à ouverture synthétique.
210 LA SEGMENTATION DES IMAGES
211 ==========================
212 Segmentation par contour actif
216 SEGMENTATION PAR CONTOUR ACTIF
217 ==============================
221 La segmentation par contour actif regroupe des méthodes itératives tendant à faire converger, par déformations successives, une courbe paramétrique (contour) selon un critère d'homogénéité pré-établi :
223 - La classe d'algorithmes la plus implémentée sur GPU est celle des **level-set**, essentiellement dans sa variante *bande étroite*.
224 - La classe des **snakes** n'est implémentée sur GPU qu'au travers la variante GVF (Gradient Vector Flow).
226 .. figure:: img/l7-gvf.png
229 À gauche : Level-set, évolution du contour, en rouge (d'après J. Sethian). À droite : visualisation du champ de force d'un *snake* GVF (d'après C. Xu).
233 * Le domaine médical recèle la quasi totalité des implémentations GPU d'algorithmes de segmentation.
234 * Nombre d'entre elles concernent des traitements effectués en 3D par nécessité, où l'emploi du GPU s'impose assez naturellement.
238 SEGMENTATION PAR CONTOUR ACTIF
239 ==============================
240 Travaux de référence (level-set)
241 --------------------------------
243 L'implémentation de Roberts *et al.* du *level-set* à *bande étroite* est actuellement la plus performante et parvient à segmenter des images d'IRM
245 - 3D, de 256x256x256 pixels, sur GTX280, en **11 000 ms**
247 .. figure:: img/brain3D.png
250 À gauche : évolution du contour pour une *tranche* avec, en bleu, les zones actives. À droite : visualisation en 3D de la segmentation complète.
254 SEGMENTATION PAR CONTOUR ACTIF
255 ==============================
256 Travaux de référence (snake)
257 ----------------------------
259 * La référence est l'implémentation *snake GVF* de Smistad *et al.* qui parvient à segmenter des images d'IRM
261 - 2D, de 512x512 pixels, sur C2070, en **41 ms**.
262 - 3D, de 256x256x256 pixels, sur C2070, en **7151 ms**
264 .. figure:: img/brain3D-gvf.png
267 À gauche : une image 2D d'IRM. À droite : visualisation en 3D de la segmentation complète.
271 * À notre connaissance, aucune publication ne décrit d'implémentation de *snake* polygonal ou de *snake* orienté région.
275 SEGMENTATION PAR CONTOUR ACTIF
276 ===============================
277 *Snake* polygonal orienté région (principe)
278 -------------------------------------------
286 * - .. image:: img/snake-modele.png
288 - * L'objectif est de déterminer le contour le plus *vraisemblable* (nombre et positions des n |oe| uds).
289 * Le critère de vraisemblance généralisée est, dans le cas gaussien :
293 $$GL = \frac{1}{2}\left[ n_B.log\left(\sigma_B^2\right) + n_T.log\left(\sigma_T^2\right)\right]$$
295 * Les deux régions, intérieure et extérieure (T et B), sont prises en compte dans l'évaluation du contour.
296 * Les variances :math:`\(\sigma^2\)` doivent être calculées pour chaque état du contour, ce qui est **très coûteux**.
300 * Cela permet d'extraire des formes aux contours mal définis, en raison d'un fort niveau de bruit par exemple.
304 SEGMENTATION PAR CONTOUR ACTIF
305 ===============================
306 *Snake* polygonal orienté région (principe)
307 --------------------------------------------
309 .. image:: img/snake-modele.png
312 * Chesnaud *et al.* ont montré comment remplacer la sommation 3D par une **sommation 2D** le long du contour.
313 * Implique le **pré-calcul** des trois images cumulées
317 $$S_1(i,j)=\sum_{x=0}^jx \text{ , } S_x(i,j)=\sum_{x=0}^jI(i,x) \text{ et } S_{x^2}(i,j)=\sum_{x=0}^jI(i,x)^2$$
321 * Les valeurs des éléments de ces images cumulées permettent de calculer la **contribution** de chaque pixel du contour, puis de chaque segment, aux calculs des variances.
325 SEGMENTATION PAR CONTOUR ACTIF
326 ===============================
327 *Snake* polygonal orienté région (algo CPU)
328 --------------------------------------------
330 .. image:: img/cochons-it0-it1.png
335 #. Le contour initial est rectangulaire ( 4 n |oe| uds )
336 #. On déplace successivement les 4 n |oe| uds jusqu'à ce que plus aucun nouveau déplacement ne provoque l'amélioration du critère.
341 SEGMENTATION PAR CONTOUR ACTIF
342 ===============================
343 *Snake* polygonal orienté région (algo CPU)
344 --------------------------------------------
346 .. image:: img/cochons-it21-it22.png
351 3. Ajout de n |oe| uds au milieu des segments suffisamment grands.
352 #. On recommence à évaluer les déplacements successifs des n |oe| uds.
356 SEGMENTATION PAR CONTOUR ACTIF
357 ===============================
358 *Snake* polygonal orienté région (algo CPU)
359 --------------------------------------------
361 .. image:: img/cochons-it4-it5.png
364 **Itérations 4 et 5**
368 SEGMENTATION PAR CONTOUR ACTIF
369 ===============================
370 *Snake* polygonal orienté région (algo CPU)
371 --------------------------------------------
373 .. figure:: img/im014.png
376 Image de 512x512 : contour final de 256 n |oe| uds en 14ms.
378 * Les résultats de segmentation dépendent des paramètres de la séquence d'optimisation (pas des déplacements, contour initial, seuil d'ajout des n |oe| uds)
382 SEGMENTATION PAR CONTOUR ACTIF
383 ===============================
384 *Snake* polygonal orienté région (algo CPU)
385 --------------------------------------------
387 .. figure:: img/snakegpu1.png
390 Image de 4000x4000 : contour final de 447 n |oe| uds en 700ms.
394 SEGMENTATION PAR CONTOUR ACTIF
395 ===============================
396 Parallélisation du *Snake* polygonal sur GPU
397 --------------------------------------------
398 Identification des fonctions coûteuses
400 .. image:: img/algosnake1.png
405 SEGMENTATION PAR CONTOUR ACTIF
406 ===============================
407 Parallélisation du *Snake* polygonal sur GPU
408 --------------------------------------------
409 Détail de la fonction de calcul du critère GL
411 .. image:: img/algosnake2b.png
417 SEGMENTATION PAR CONTOUR ACTIF
418 ===============================
419 Parallélisation du *Snake* polygonal sur GPU
420 --------------------------------------------
422 .. image:: img/snake-pairimpair.png
427 * Pour un n |oe| ud et un pas de déplacement donnés, on évalue **en parallèle** 8 positions voisines, soit 16 segments distincts.
428 * Pour éviter les oscillations et *coller* à l'algorithme séquentiel, on distingue les n |oe| uds d'indices pairs et impairs.
429 * On évalue **en parallèle** l'ensemble des déplacements éventuels de tous les n |oe| uds de même parité.
433 SEGMENTATION PAR CONTOUR ACTIF
434 ===============================
435 Parallélisation du *Snake* polygonal sur GPU
436 --------------------------------------------
438 **Structure des données** (n |oe| uds pairs)
440 .. image:: img/16segments.png
445 * règle 1 thread par pixel
449 SEGMENTATION PAR CONTOUR ACTIF
450 ===============================
451 Parallélisation du *Snake* polygonal sur GPU
452 --------------------------------------------
454 **Obtention du critère**
456 * Parallélisation : 1 thread par pixel.
457 * Une seule taille de segment : la taille du plus long.
458 * Bourrage avec des threads inactifs pour les segments plus courts.
459 * Calcul réalisé en 3 étapes par 3 fonctions parallèles GPU (*kernels*)
461 #. Calculs réalisables **au niveau bloc** : coordonnées des pixels, lecture des paramètres dans les images cumulées, sommes partielles des contributions des segments.
462 #. **Réductions** : calcul final des contributions des segments.
463 #. Calcul des valeurs du critère pour chaque contour évalué. Sélection du meilleur contour.
467 * les réduction consistent à sommer, pour chaque segment les contributions partielles par bloc calculées au 1
472 SEGMENTATION PAR CONTOUR ACTIF
473 ===============================
474 Parallélisation du *Snake* polygonal sur GPU
475 --------------------------------------------
477 **Propriétés de l'implémentation**
479 * Conservation des données en mémoire GPU.
480 * Les images cumulées sont calculées en parallèle.
481 * Abandon de l'algorithme de Bresenham pour la discretisation des segments.
482 * Trop peu de calculs à effectuer. Peu de threads dans la grille.
483 * Pas de coalescence possible dans les accès à la mémoire globale.
484 * Emploi de la mémoire partagée.
488 * Un seul entier est échangé entre le CPU et le GPU à chaque itération.
489 * image cumulées par une adaptation de la méthode des sommes de préfixes.
490 * Abandon Bresenham Possible car parcours unidirectionnel du contour.
491 * Trop peu de calculs ne permet pas de masquer les latences.
492 * Pas de coalescence possible dans les accès à la mémoire globale car la géométrie des segments varie.
493 * mémoire partagée à cause des réductions.
497 SEGMENTATION PAR CONTOUR ACTIF
498 ===============================
499 Parallélisation du *Snake* polygonal sur GPU
500 --------------------------------------------
502 **Performances de l'implémentation**
504 .. image:: img/perfs-snake.png
509 .. image:: img/perfs-snake-img.png
514 SEGMENTATION PAR CONTOUR ACTIF
515 ===============================
516 Parallélisation du *Snake* polygonal sur GPU
517 --------------------------------------------
521 * Première et seule implémentation à ce jour.
522 * Performances intéressantes pour les grandes images. 1OO MP en moins de 0,6 seconde.
523 * Temps de calcul très dépendant du contenu de l'image.
524 * Le GPU n'est pas employé de manière optimale : réductions, threads inactifs, non coalescence.
525 * Le GPU apporte un gain important sur les premières itérations, quand les segments sont grands.
526 * Initialisation optionnelle par maximum de vraisemblance. Accélération jusqu'à x15 avec de petites cibles.
530 LE FILTRAGE DES IMAGES
531 ======================
532 Filtre médian - Filtres de convolution - Filtre par lignes de niveaux
536 LE FILTRAGE DES IMAGES
537 ======================
543 LE FILTRAGE DES IMAGES
544 ======================
545 Filtre médian : principe
546 ------------------------
548 .. image:: img/median-principe.png
551 La valeur de sortie d'un pixel est la **médiane** des valeurs de son voisinage.
553 * Bonne réduction de bruits gaussien et *poivre & sel*
554 * Valeurs de sortie appartenant au voisinage.
555 * Opération de sélection coûteuse (tri).
556 * Usages fréquents avec des petites fenêtres (de 3x3 à 7x7).
557 * Quelques applications avec de grandes fenêtres (au delà de 21x21).
561 LE FILTRAGE DES IMAGES
562 ======================
563 Filtre médian : usage
564 ---------------------
568 =================================== ======================================== ============================================
569 .. image:: img/airplane_sap25.png .. image:: img/airplane_sap25_med5.png .. image:: img/airplane_sap25_med3_it2.png
570 =================================== ======================================== ============================================
571 Bruit *poivre & sel* 25% Médian 5x5 Médian 3x3 - 2 passes
572 =================================== ======================================== ============================================
576 LE FILTRAGE DES IMAGES
577 ======================
578 Filtre médian GPU : Travaux de référence
579 ----------------------------------------
581 * Sanchez *et al.* ont proposé le **PCMF** et l'ont comparé, sur C2075, avec les implémentations GPU de référence pour une image 8 bits de 512x512 (débit max. **80 MP/s**) :
583 - **ArrayFire**, bibliothèque commerciale, débit max. **185 MP/s**
584 - **BVM** parallélisé par Kachelrie |B|, débit max. **110 MP/s**
586 .. image:: img/compar-median2.png
591 * PCMF : Parallel (Complementary Cumulative Derivative Function) Median Filter (histogrammes cumulatifs)
592 * CTMF : CPU à temps constant
596 LE FILTRAGE DES IMAGES
597 ======================
598 Filtre médian GPU : Travaux de référence
599 ----------------------------------------
601 Emploi de la **mémoire partagée** pour pré-charger les valeurs utiles à chaque bloc de threads.
603 .. image:: img/shmemhalo.png
608 LE FILTRAGE DES IMAGES
609 ======================
610 Optimisation du filtre médian GPU
611 ---------------------------------
613 Transferts des données optimisés
615 .. image:: img/CPU-GPU-memcpy.png
618 .. image:: img/transferts-mem.png
623 On gagne de 13 à 43 % sur les temps de transfert.
627 LE FILTRAGE DES IMAGES
628 ======================
629 Optimisation du filtre médian GPU
630 ---------------------------------
633 .. image:: img/CPU-GPU-memcpy-dummykernel.png
637 Débits maximums effectifs, en MP/s, pour des images en 8 et 16 bits, incluant les transferts optimisés (C2070).
639 .. image:: img/debit-max-2070.png
642 **Rappel :** PCMF : 80 MP/s - BVM : 110 MP/s - ArrayFire : 185 MP/s
646 ça laisse environ 80ms pour faire un tri de 9 valeurs sur une image de 4096x4096
650 LE FILTRAGE DES IMAGES
651 ======================
652 Optimisation du filtre médian GPU
653 ---------------------------------
655 **Sélection de la médiane**
657 * Emploi exclusif des **registres** pour charger les valeurs utiles.
658 * Limitations à 63 registres par thread et 32 K par bloc de threads.
659 * Envisageable pour les médians de petite taille (jusqu'à 7x7 avec 1 thread/pixel).
660 * Exploitation des recouvrements entre fenêtres de pixels voisins.
665 LE FILTRAGE DES IMAGES
666 ======================
667 Optimisation du filtre médian GPU
668 ---------------------------------
670 **Sélection de la médiane** (par oubli)
678 * - Bonnes performances envisagées :
680 * Économie de registres.
681 * Évite le tri complet.
682 - .. image:: img/forgetful_selection.png
687 LE FILTRAGE DES IMAGES
688 ======================
689 Optimisation du filtre médian GPU
690 ---------------------------------
692 **Exploitation des recouvrements**
694 .. image:: img/recouvrement5.png
697 **Intérêt :** Économie de registres - chaque thread traite 2 pixels.
701 * chaque thread utilise plus de registres
702 * mais sur un bloc, en adaptant la taille du bloc, on économise k+1 registres par paire de pixels.
706 LE FILTRAGE DES IMAGES
707 ======================
708 Optimisation du filtre médian GPU
709 ---------------------------------
711 **Masquage des latences**
713 * Accès à la mémoire globale : 2 pixels par thread.
714 * Instruction Level Parallelism (ILP) : Ordre des instructions minimisant l'interdépendance.
716 .. figure:: img/bitonic.png
719 Identification des extrema dans le vecteur initial d'un médian 5x5
723 * au delà de 2 pixels par thread, le gain sur les latences est compensé par la perte sur le calcul / niveau de parallèlisme.
724 * ILP maximisée en appliquant une méthode simple; utilisée par ex. dans la technique des réseaux de tri bitoniques.
728 LE FILTRAGE DES IMAGES
729 ======================
730 Performances du filtre médian GPU proposé (PRMF)
731 ------------------------------------------------
733 .. image:: img/perf-median.png
738 LE FILTRAGE DES IMAGES
739 ======================
740 Performances du filtre médian GPU proposé (PRMF)
741 ------------------------------------------------
745 .. image:: img/comp512.png
750 .. image:: img/comp4k.png
755 LE FILTRAGE DES IMAGES
756 ======================
762 * Pas d'utilisation de la mémoire partagée.
763 * Débit global amélioré de x7 à x10, proche du maximum.
764 * Débit de calcul atteignant **5,3 GP/s**.
765 * Médian jusqu'au 9x9 sur C2070, 21x21 sur K40.
766 * Création d'une application web générant les codes sources.
767 * Utilisé pour le pré-traitement d'images de cristallographie au synchrotron **SPring-8** (Japon).
769 .. image:: img/SPring8.png
774 LE FILTRAGE DES IMAGES
775 ======================
776 Les filtres de convolution
777 --------------------------
781 LE FILTRAGE DES IMAGES
782 ======================
783 Les filtres de convolution : généralités
784 -----------------------------------------
790 $$I_{out}(x, y) = \left(I_{in} * h\right) = \sum_{(i < H)} \sum_{(j < L)}I_{in}(x-j, y-i)h(j,i)$$
792 **Usage, selon les valeurs du masque h**
794 * réduction de bruit,
795 * détection de bords,...
799 * selon h --> convo séparable ou non séparable
803 LE FILTRAGE DES IMAGES
804 ======================
805 Les filtres de convolution GPU
806 ------------------------------
808 Le fabricant Nvidia propose la plus rapide des implémentations connue :
810 Convolution **non séparable** sur image de 2048x2048, masque h de 5x5, sur **GTX280**.
812 * Débit global : **945 MP/s**.
813 * Débit de calcul : **3,00 GP/s**
817 LE FILTRAGE DES IMAGES
818 ======================
819 Les filtres de convolution GPU
820 ------------------------------
822 Exploitation des recouvrements
824 * un seul accès mémoire par pixel, mémorisation en registre.
825 * mise à jour de tous les calculs concernés
827 .. image:: img/convoOverlap2.png
830 Application des techniques présentées pour le filtre médian :
832 * Optimum à 8 pixels par thread.
833 * Débit global : **966 MP/s**.
834 * Débit de calcul : **3,47 GP/s**
836 Sur **C2070**, nos débits sont de **1666 MP/S** et **5280 MP/s**. Les débits maximum atteignent **2140 MP/s** et **8540 MP/s** (4090x4096, masque 3x3)
840 LE FILTRAGE DES IMAGES
841 ======================
842 Les filtres de convolution GPU
843 ------------------------------
845 Convolution **séparable** sur C2070.
847 Implémentation Nvidia (mémoire partagée)
849 * Débit global max : **1933 MP/s**.
850 * Débit de calcul max : **6000 MP/s**
854 * Optimum à 8 pixels par thread.
855 * Une convolution 1D en mémoire partagée, l'autre en registres. Copie intermédiaire en mémoire globale (cache 1D rapide).
856 * Débit global : **2028 MP/s**.
857 * Débit de calcul : **7626 MP/s**
858 * Le gain est obtenu sur la convolution 1D en registres.
862 LE FILTRAGE DES IMAGES
863 ======================
864 Les filtres de convolution GPU
865 ------------------------------
869 * Amélioration limitée des débits globaux en raison de la prépondérance des temps de transfert.
870 * Amélioration sensible sur les débits de calcul (de 17 à 33 %).
871 * Le traitement 1D est jusqu'à 66% plus rapide. Applicable à d'autres signaux 1D.
875 LE FILTRAGE DES IMAGES
876 ======================
877 Filtre par recherche des lignes de niveaux
878 ------------------------------------------
882 LE FILTRAGE DES IMAGES
883 ======================
884 Filtre par recherche des lignes de niveaux
885 ------------------------------------------
889 * Les algorithmes qui débruitent le mieux sont lents (BM3D).
890 * Les images naturelles sont décomposables en un ensemble de lignes de niveaux ( iso-niveau de gris ).
891 * Concevoir un algorithme GPU original et son implémentation.
895 LE FILTRAGE DES IMAGES
896 ======================
897 Filtre par recherche des lignes de niveaux
898 ------------------------------------------
900 **Principe - modèle**
902 * Estimation locale, par maximum de vraisemblance, des lignes de niveaux.
903 * Réduction de bruit par moyennage le long de la ligne estimée.
904 * Les lignes de niveaux estimées sont modélisées par des lignes brisées nommées **isolines**.
905 * Les segments des lignes brisées sont choisis parmi des motifs pré-établis (32 motifs).
908 .. image:: img/P5Q1.png
914 LE FILTRAGE DES IMAGES
915 ======================
916 Filtre par recherche des lignes de niveaux
917 ------------------------------------------
919 **Principe (étape 1)**
921 * En chaque pixel, recherche du motif maximisant la log-vraisemblance ( :math:`\(n=6, \sigma^2 =\)` variance )
925 $$-\frac{n}{2}log\left(2\pi\right) - \frac{n}{2}log\left(\sigma^2\right) - \frac{n}{2}$$
927 * Mémorisation des paramètres des motifs sélectionnés dans deux matrices :math:`\(I_{\Theta}\)` et :math:`\(I_{\Sigma}\)`.
929 .. image:: img/lniv-mv.png
934 LE FILTRAGE DES IMAGES
935 ======================
936 Filtre par recherche des lignes de niveaux
937 ------------------------------------------
939 **Principe (étape 2)**
941 * Allongement itératif des segments sous condition GLRT.
945 $$(n_{s_1s_2}+n_{s_3})\left[log\left(\widehat{\sigma_{s_1s_2}}^2\right) - log\left(\widehat{\sigma_{s_3}}^2\right) \right]$$
947 .. image:: img/pipd-detail.png
952 LE FILTRAGE DES IMAGES
953 ======================
954 Filtre par recherche des lignes de niveaux
955 ------------------------------------------
957 **Principe (étape 3)**
959 Compensation de la non robustesse de sélection des motifs dans les zones homogènes.
961 * identification des zones homogènes avec un détecteur de bords.
962 * Application d'un filtre moyenneur dans ces zones.
964 .. image:: img/detecteur.png
969 * Sous-ensembles de pixels n'ayant pas d'intersection --> MV
970 * Utilisation des motifs des segments pour gain de temps.
974 LE FILTRAGE DES IMAGES
975 ======================
976 Filtre par recherche des lignes de niveaux
977 ------------------------------------------
981 Sur l'ensemble d'images de S. Lansel (DenoiseLab, Université Stanford), filtre proposé (PI-PD)
983 * Amélioration moyenne du rapport Signal sur bruit: **+7,1 dB**
984 * Indice de similarité structurelle : **+30%**
985 * Temps de calcul : **7 ms**
987 Comparaison avec BM3D
989 * Amélioration moyenne du rapport Signal sur bruit: **+9,5 dB**
990 * Indice de similarité structurelle : **+36%**
991 * Temps de calcul : **4300 ms**
995 LE FILTRAGE DES IMAGES
996 ======================
997 Filtre par recherche des lignes de niveaux
998 ------------------------------------------
1002 ============================================ === ========================================
1003 .. image:: img/zoom_noisy.png .. image:: img/zoom_mean5.png
1005 Bruit gaussien :math:`\(\sigma=25\)` Moyennage 5x5
1007 .. image:: img/zoom_pipdh.png .. image:: img/zoom_bm3d.png
1010 ============================================ === ========================================
1014 LE FILTRAGE DES IMAGES
1015 ======================
1016 Filtre par recherche des lignes de niveaux
1017 ------------------------------------------
1019 **Synthèse - conclusion**
1021 * Rapport qualité/temps élevé.
1022 * Traitement d'images HD à 20 fps.
1023 * Artefacts en marche d'escalier. Réduits par la méthode de Buades *et al.* (+1 dB, +0,2 ms pour 512x512).
1024 * Extension aux images couleurs et autres types de bruits (multiplicatif).
1025 * Algorithme original sans implémentation séquentielle de référence.
1029 CONCLUSION GÉNÉRALE - PERSPECTIVES
1030 ==================================
1032 * Trois types de conception mis en |~oe| uvre.
1033 * Le portage efficace d'algorithme peut s'avérer très complexe, voire sans intérêt.
1034 * L'emploi de la mémoire partagée n'apporte pas les meilleures performances en cas de recouvrements.
1035 * Filtres utilisables par tout programmeur grâce à un générateur de code.
1036 * Beaucoup de traitements et domaines peuvent bénéficier des techniques proposées.
1037 * Les évolutions de l'architecture laissent entrevoir de nouvelles possibilités.
1042 * certaines ardeurs ont été refroidies
1044 .. |oe| unicode:: U+0153
1047 .. |~oe| unicode:: U+0153
1051 .. |B| unicode:: U+00DF
