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 parrallèles 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 +++++++++++++++++++++++++++++++++++++
48 PLAN DE LA PRÉSENTATION
49 =======================
51 #. Introduction - cadre des travaux
53 - Les GPUs (Graphical Processing Units)
54 - Généralités sur le traitement d'image. Nos axes de recherche.
56 #. La segmentation des images
58 - Généralités. Travaux de référence.
59 - Parallélisation GPU d'un algorithme de segmentation de type *snake*.
61 #. Le filtrage des images
63 - Généralités. Travaux de référence.
64 - Optimisation pour GPU des filtres médian et de convolution.
65 - Conception d'un algorithme parallèle de réduction de bruit par recherche des lignes de niveaux.
67 #. Synthèse et conclusion.
78 Les GPUs ou *Processeurs graphiques*.
79 -------------------------------------
81 .. image:: img/gpucpu1.png
85 * Processeurs *classiques* **CPU** : exécution **séquentielle**
87 - Quelques unités de calcul ( les c |oe| urs).
89 * Processeurs *graphiques* **GPU** : exécution **massivement parallèle**
91 - Des centaines, voire millier, d'unités de calcul, regroupées en quelques SMs (*Streaming Multiprocessors*).
97 Les GPUs ou *Processeurs graphiques*.
98 -------------------------------------
100 * La multiplication des c |oe| urs dans les GPUs se fait au détriment des fonctions de contrôle et de cache.
101 * Seule la mémoire *globale* est accessible par l'ensemble des fils d'exécution (les *threads*) et ses performances sont faibles.
102 * L'accès efficace aux différents types de mémoires est contraignant.
103 * Les échanges de données entre le GPU et son hôte CPU sont pénalisants.
104 * 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.
105 * 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 * Beaucoup d'applications sont basées sur l'analyse ou la visualisation d'images numériques.
115 * Les capteurs numériques et les conditions d'acquisition sont à l'origine de perturbations (bruits) qui dégradent l'image de la scène idéale et peuvent en fausser ou compliquer l'interprétation.
116 * La réduction de bruit demeure un thème important, car les hautes résolutions sont souvent obtenues à faible flux de photons, dont les variations engendrent du bruit.
117 * La segmentation représente aussi un enjeu crucial, mais aucun algorithme universel n'a encore été élaboré.
121 * on recense plus de 4000 algorithmes de segmentation
122 * La segmentation intervient dans beaucoup d'applications : du tracking à la détection ou à l'extraction de caractéristiques diverses.
123 * 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.
129 Le traitement des images
130 ------------------------
132 * L'accroissement des capacités de calcul a suivi l'augmentation des résolutions d'images.
133 * 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.
134 * 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 des accélérations importantes pour d'autres.
136 **Nos travaux sont une contribution à cette recherche de performance.**
140 * La croissance des capacités de calcul des GPUs à été beaucoup plus forte que celle des CPUs.
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 * permet, *a priori*, de réduire le 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 * permet de ne pas subir la perte d'information occasionnée par le 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 (fortement) par contours actifs, appartenant à la classe communément appelée *snakes*.
179 **Filtrage : accélérer les pré-traitements**
181 Réduction de bruit additif gaussien, suivant deux méthodes de conception :
183 * algorithme original, conçu spécifiquement pour GPU, conjointement à son implémentation.
184 * algorithmes existants, où l'effort de conception ne peut porter que sur l'implémentation : filtres médian et de convolution.
195 * Nous nous sommes focalisés sur les *images naturelles* :
197 - réalisées en lumière naturelle, en intérieur aussi bien qu'en extérieur,
198 - prises avec un dispositif standard (CMOS, CCD).
200 * Les traitements que nous présentons ici opèrent sur des images en
201 niveau de gris (8 ou 16 bits).
205 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.
209 LA SEGMENTATION DES IMAGES
210 ==========================
211 Segmentation par contour actif
215 SEGMENTATION PAR CONTOUR ACTIF
216 ==============================
220 * Le domaine médical recèle la quasi totalité des implémentations GPU d'algorithmes de segmentation.
221 * Nombre d'entre elles concernent des traitements effectués en 3D par nécessité, où l'emploi du GPU s'impose assez naturellement.
222 * La segmentation par contour actif regroupe des méthodes itératives tendant à faire converger, par déformation successive, une courbe paramétrique (contour) selon un critère d'homogénéité pré-établi :
224 - La classe d'algorithmes la plus implémentée est celle des **level-set**, essentiellement dans sa variante *bande étroite*.
225 - La classe des **snakes** n'est implémentée qu'au travers la variante GVF (Gradient Vector Flow).
227 .. figure:: img/l7-gvf.png
230 À gauche : Level-set, évolution du contour, en rouge. À droite : visualisation du champ de force d'un *snake* GVF.
234 SEGMENTATION PAR CONTOUR ACTIF
235 ==============================
236 Travaux de référence (level-set)
237 --------------------------------
239 L'implémentation de Roberts *et al.* du *level-set* à *bande étroite* est actuellement la plus performante et parvient à segmenter des images d'IRM
241 - 3D, de 256x256x256 pixels, sur GTX280, en **11 000 ms**
243 .. figure:: img/brain3D.png
246 À gauche : évolution du contour pour une *tranche* avec, en bleu, les zones actives. À droite : visualisation en 3D de la segmentation complète.
250 SEGMENTATION PAR CONTOUR ACTIF
251 ==============================
252 Travaux de référence (snake)
253 ----------------------------
255 * À notre connaissance, aucune publication ne décrit d'implémentation de *snake* polygonal ou de *snake* orienté région.
256 * La référence est l'implémentation *snake GVF* de Smistad *et al.* qui parvient à segmenter des images d'IRM
258 - 2D, de 512x512 pixels, sur C2070, en **41 ms**.
259 - 3D, de 256x256x256 pixels, sur C2070, en **7151 ms**
261 .. figure:: img/brain3D-gvf.png
264 À gauche : une image 2D d'IRM. À droite : visualisation en 3D de la segmentation complète.
268 SEGMENTATION PAR CONTOUR ACTIF
269 ===============================
270 *Snake* polygonal orienté région (principe)
271 -------------------------------------------
279 * - .. image:: img/snake-modele.png
281 - * L'objectif est de déterminer le contour le plus *vraisemblable* (nombre et positions des n |oe| uds).
282 * Le critère de vraisemblance généralisée est, dans le cas gaussien :
286 $$GL = \frac{1}{2}\left[ n_B.log\left(\sigma_B^2\right) + n_T.log\left(\sigma_T^2\right)\right]$$
288 * Les deux régions, intérieure et extérieure (T et B), sont prises en compte dans l'évaluation du contour. Cela permet d'extraire des formes aux contours mal définis, en raison d'un fort niveau de bruit par exemple.
289 * Les variances :math:`\(\sigma^2\)` doivent être calculées pour chaque état du contour, ce qui est **très coûteux**.
293 SEGMENTATION PAR CONTOUR ACTIF
294 ===============================
295 *Snake* polygonal orienté région (principe)
296 --------------------------------------------
298 * Chesnaud *et al.* ont montré comment réaliser le calcul des variances par une **sommation 2D** le long du contour, au lieu d'une classique sommation 3D sur la surface des régions concernées.
299 * Cette optimisation algorithmique implique de **pré-calculer** les trois images cumulées
303 $$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$$
305 * 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.
309 SEGMENTATION PAR CONTOUR ACTIF
310 ===============================
311 *Snake* polygonal orienté région (algo CPU)
312 --------------------------------------------
314 .. image:: img/cochons-it0-it1.png
319 #. Le contour initial est rectangulaire ( 4 n |oe| uds )
320 #. 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.
325 SEGMENTATION PAR CONTOUR ACTIF
326 ===============================
327 *Snake* polygonal orienté région (algo CPU)
328 --------------------------------------------
330 .. image:: img/cochons-it21-it22.png
335 3. Ajout de n |oe| uds au milieu des segments suffisamment grands.
336 #. On recommence à évaluer les déplacements successifs des n |oe| uds.
340 SEGMENTATION PAR CONTOUR ACTIF
341 ===============================
342 *Snake* polygonal orienté région (algo CPU)
343 --------------------------------------------
345 .. image:: img/cochons-it4-it5.png
348 **Itérations 4 et 5**
352 SEGMENTATION PAR CONTOUR ACTIF
353 ===============================
354 *Snake* polygonal orienté région (algo CPU)
355 --------------------------------------------
357 .. figure:: img/im014.png
360 Image de 512x512 : contour final de 256 n |oe| uds en 14ms.
362 * 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)
366 SEGMENTATION PAR CONTOUR ACTIF
367 ===============================
368 *Snake* polygonal orienté région (algo CPU)
369 --------------------------------------------
371 .. figure:: img/snakegpu1.png
374 Image de 4000x4000 : contour final de 447 n |oe| uds en 700ms.
378 SEGMENTATION PAR CONTOUR ACTIF
379 ===============================
380 Parallélisation du *Snake* polygonal sur GPU
381 --------------------------------------------
382 Identification des fonctions coûteuses
384 .. image:: img/algosnake1.png
389 SEGMENTATION PAR CONTOUR ACTIF
390 ===============================
391 Parallélisation du *Snake* polygonal sur GPU
392 --------------------------------------------
393 Détail de la fonction de calcul du critère GL
395 .. image:: img/algosnake2b.png
401 SEGMENTATION PAR CONTOUR ACTIF
402 ===============================
403 Parallélisation du *Snake* polygonal sur GPU
404 --------------------------------------------
406 .. image:: img/snake-pairimpair.png
411 * 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.
412 * Pour éviter les oscillations et *coller* à l'algorithme séquentiel, on distingue les n |oe| uds d'indices pairs et impairs.
413 * On évalue **en parallèle** l'ensemble des déplacements éventuels de tous les n |oe| uds de même parité.
417 SEGMENTATION PAR CONTOUR ACTIF
418 ===============================
419 Parallélisation du *Snake* polygonal sur GPU
420 --------------------------------------------
422 **Structure des données** (n |oe| uds pairs)
424 .. image:: img/snake-segments-pairs.png
429 * règle 1 thread par pixel
433 SEGMENTATION PAR CONTOUR ACTIF
434 ===============================
435 Parallélisation du *Snake* polygonal sur GPU
436 --------------------------------------------
438 **Obtention du critère**
440 * Parallélisation : 1 thread par pixel.
441 * Une seule taille de segment : la taille du plus long.
442 * Bourrage avec des threads inactifs pour les segments plus courts.
443 * Calcul réalisé en 3 étapes par 3 fonctions parallèles GPU (*kernels*)
445 #. Calcul des coordonnées des pixels. Lecture des paramètres de chaque pixel dans les images cumulées. Sommes partielles, par bloc, des contributions des segments.
446 #. Calcul final des contributions des segments par sommation des résultats du *kernel* précedent.
447 #. Calcul des valeurs du critère pour chaque contour évalué. Sélection du meilleur contour.
452 SEGMENTATION PAR CONTOUR ACTIF
453 ===============================
454 Parallélisation du *Snake* polygonal sur GPU
455 --------------------------------------------
457 **Propriétés de l'implémentation**
459 * Conservation des données en mémoire GPU.
460 * Les images cumulées sont calculées en parallèle.
461 * Abandon de l'algorithme de Bresenham pour la discretisation des segments.
462 * Trop peu de calculs à effectuer.
463 * Pas de coalescence possible dans les accès à la mémoire globale.
464 * Emploi de la mémoire partagée.
468 * Un seul entier est échangé entre le CPU et le GPU à chaque itération.
469 * image cumulées par une adaptation de la méthode des sommes de préfixes.
470 * Abandon Bresenham Possible car parcours unidirectionnel du contour.
471 * Trop peu de calculs ne permet pas de masquer les latences.
472 * Pas de coalescence possible dans les accès à la mémoire globale car la géométrie des segments varie.
473 * mémoire partagée à cause des réductions.
477 SEGMENTATION PAR CONTOUR ACTIF
478 ===============================
479 Parallélisation du *Snake* polygonal sur GPU
480 --------------------------------------------
482 **Performances de l'implémentation**
484 .. image:: img/perfs-snake.png
489 .. image:: img/perfs-snake-img.png
494 SEGMENTATION PAR CONTOUR ACTIF
495 ===============================
496 Parallélisation du *Snake* polygonal sur GPU
497 --------------------------------------------
501 * Première et seule implémentation à ce jour.
502 * Performances intéressantes pour les grandes images. 1OO MP en moins de 0,6 seconde.
503 * Temps de calcul très dépendant du contenu de l'image.
504 * Le GPU n'est pas employé de manière optimale : réductions, threads inactifs, non coalescence.
505 * Le GPU apporte un gain important sur les premières itérations, quand les segments sont grands.
506 * Initialisation optionnelle par maximum de vraisemblance. Accélération jusqu'à x15 avec de petites cibles.
510 LE FILTRAGE DES IMAGES
511 ======================
512 Filtre médian - Filtres de convolution - Filtre par lignes de niveaux
516 LE FILTRAGE DES IMAGES
517 ======================
523 LE FILTRAGE DES IMAGES
524 ======================
525 Filtre médian : principe
526 ------------------------
528 .. image:: img/median-principe.png
531 La valeur de sortie d'un pixel est la **médiane** des valeurs de son voisinage.
533 * Bonne réduction de bruits gaussien et *poivre & sel*
534 * Valeurs de sortie appartenant au voisinage.
535 * Opération de sélection coûteuse (tri).
536 * Usages fréquents avec des petites fenêtres (de 3x3 à 7x7).
537 * Quelques applications avec de grandes fenêtres (au delà de 21x21).
541 LE FILTRAGE DES IMAGES
542 ======================
543 Filtre médian : usage
544 ---------------------
548 =================================== ======================================== ============================================
549 .. image:: img/airplane_sap25.png .. image:: img/airplane_sap25_med5.png .. image:: img/airplane_sap25_med3_it2.png
550 =================================== ======================================== ============================================
551 Bruit *poivre & sel* 25% Médian 5x5 Médian 3x3 - 2 passes
552 =================================== ======================================== ============================================
556 LE FILTRAGE DES IMAGES
557 ======================
558 Filtre médian GPU : Travaux de référence
559 ----------------------------------------
561 * 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**) :
563 - **ArrayFire**, bibliothèque commerciale, débit max. **185 MP/s**
564 - **BVM** parallélisé par Kachelrie |B|, débit max. **110 MP/s**
566 .. image:: img/compar-median2.png
571 * PCMF : Parallel (Complementary Cumulative Derivative Function) Median Filter (histogrammes cumulatifs)
572 * CTMF : CPU à temps constant
576 LE FILTRAGE DES IMAGES
577 ======================
578 Filtre médian GPU : Travaux de référence
579 ----------------------------------------
581 Emploi de la **mémoire partagée** pour pré-charger les valeurs utiles à chaque bloc de threads.
583 .. image:: img/shmemhalo.png
588 LE FILTRAGE DES IMAGES
589 ======================
590 Optimisation du filtre médian GPU
591 ---------------------------------
593 Transferts des données optimisés
595 CPU :math:`\(\rightarrow\)` GPU texture :KERNEL: GPU globale :math:`\(\rightarrow\)` CPU non paginée
597 .. image:: img/transferts-mem.png
602 On gagne de 13 à 43 % sur les temps de transfert.
606 LE FILTRAGE DES IMAGES
607 ======================
608 Optimisation du filtre médian GPU
609 ---------------------------------
611 Débits maximums effectifs, en MP/s, pour des images en 8 et 16 bits, incluant les transferts optimisés (C2070).
613 .. image:: img/debit-max-2070.png
616 **Rappel :** PCMF : 80 MP/s - BVM : 110 MP/s - ArrayFire : 185 MP/s
620 ça laisse environ 80ms pour faire un tri de 9 valeurs sur une image de 4096x4096
624 LE FILTRAGE DES IMAGES
625 ======================
626 Optimisation du filtre médian GPU
627 ---------------------------------
629 **Sélection de la médiane**
631 * Emploi exclusif des **registres** pour charger les valeurs utiles.
632 * Limitations à 63 registres par thread et 32 K par bloc de threads.
633 * Envisageable pour les médians de petite taille (jusqu'à 7x7 avec 1 thread/pixel).
634 * Exploitation des recouvrements entre fenêtres de pixels voisins.
639 LE FILTRAGE DES IMAGES
640 ======================
641 Optimisation du filtre médian GPU
642 ---------------------------------
644 **Sélection de la médiane** (par oubli)
652 * - Bonnes performances envisagées :
654 * Économie de registres.
655 * Évite le tri complet.
656 - .. image:: img/forgetful_selection.png
661 LE FILTRAGE DES IMAGES
662 ======================
663 Optimisation du filtre médian GPU
664 ---------------------------------
666 **Exploitation des recouvrements**
668 .. image:: img/recouvrement5.png
671 **Intérêt :** Économie de registres - chaque thread traite 2 pixels.
675 * chaque thread utilise plus de registres
676 * mais sur un bloc, en adaptant la taille du bloc, on économise k+1 registres par paire de pixels.
680 LE FILTRAGE DES IMAGES
681 ======================
682 Optimisation du filtre médian GPU
683 ---------------------------------
685 **Masquage des latences**
687 * Accès à la mémoire globale : 2 pixels par thread.
688 * Instruction Level Parallelism (ILP) : Ordre des instructions minimisant l'interdépendance.
690 .. figure:: img/bitonic.png
693 Identification des extrema dans le vecteur initial d'un médian 5x5
697 * au delà de 2 pixels par thread, le gain sur les latences est compensé par la perte sur le calcul / niveau de parallèlisme.
698 * ILP maximisée en appliquant une méthode simple; utilisée par ex. dans la technique des réseaux de tri bitoniques.
702 LE FILTRAGE DES IMAGES
703 ======================
704 Performances du filtre médian GPU proposé (PRMF)
705 ------------------------------------------------
707 .. image:: img/perf-median.png
712 LE FILTRAGE DES IMAGES
713 ======================
714 Performances du filtre médian GPU proposé (PRMF)
715 ------------------------------------------------
719 .. image:: img/comp512.png
724 .. image:: img/comp4k.png
729 LE FILTRAGE DES IMAGES
730 ======================
736 * Pas d'utilisation de la mémoire partagée.
737 * Débit global amélioré de x7 à x10, proche du maximum.
738 * Débit de calcul atteignant **5,3 GP/s**.
739 * Médian jusqu'au 9x9 sur C2070, 21x21 sur K40.
740 * Création d'une application web générant les codes sources.
741 * Utilisé pour le pré-traitement d'images de cristallographie au synchrotron **SPring-8** (Japon).
743 .. image:: img/SPring8.png
748 LE FILTRAGE DES IMAGES
749 ======================
750 Les filtres de convolution
751 --------------------------
755 LE FILTRAGE DES IMAGES
756 ======================
757 Les filtres de convolution : généralités
758 -----------------------------------------
764 $$I_{out}(x, y) = \left(I_{in} * h\right) = \sum_{(i < H)} \sum_{(j < L)}I_{in}(x-j, y-i)h(j,i)$$
766 **Usage, selon les valeurs du masque h**
768 * réduction de bruit,
769 * détection de bords,...
773 * selon h --> convo séparable ou non séparable
777 LE FILTRAGE DES IMAGES
778 ======================
779 Les filtres de convolution GPU
780 ------------------------------
782 Le fabricant Nvidia propose la plus rapide des implémentations connue :
784 Convolution **non séparable** sur image de 2048x2048, masque h de 5x5, sur **GTX280**.
786 * Débit global : **945 MP/s**.
787 * Débit de calcul : **3,00 GP/s**
791 LE FILTRAGE DES IMAGES
792 ======================
793 Les filtres de convolution GPU
794 ------------------------------
796 Exploitation des recouvrements
798 * un seul accès mémoire par pixel, mémorisation en registre.
799 * mise à jour de tous les calculs concernés
801 .. image:: img/convoOverlap2.png
804 Application des techniques présentées pour le filtre médian :
806 * Optimum à 8 pixels par thread.
807 * Débit global : **966 MP/s**.
808 * Débit de calcul : **3,47 GP/s**
810 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)
814 LE FILTRAGE DES IMAGES
815 ======================
816 Les filtres de convolution GPU
817 ------------------------------
819 Convolution **séparable** sur C2070.
821 Implémentation Nvidia (mémoire partagée)
823 * Débit global max : **1933 MP/s**.
824 * Débit de calcul max : **6000 MP/s**
828 * Optimum à 8 pixels par thread.
829 * Une convolution 1D en mémoire partagée, l'autre en registres. Copie intermédiaire en mémoire globale (cache 1D rapide).
830 * Débit global : **2028 MP/s**.
831 * Débit de calcul : **7626 MP/s**
832 * Le gain est obtenu sur la convolution 1D en registres.
836 LE FILTRAGE DES IMAGES
837 ======================
838 Les filtres de convolution GPU
839 ------------------------------
843 * Amélioration limitée des débits globaux en raison de la prépondérance des temps de transfert.
844 * Amélioration sensible sur les débits de calcul (de 17 à 33 %).
845 * Le traitement 1D est jusqu'à 66% plus rapide. Applicable à d'autres signaux 1D.
849 LE FILTRAGE DES IMAGES
850 ======================
851 Filtre par recherche des lignes de niveaux
852 ------------------------------------------
856 LE FILTRAGE DES IMAGES
857 ======================
858 Filtre par recherche des lignes de niveaux
859 ------------------------------------------
863 * Les algorithmes qui débruitent le mieux sont lents (BM3D).
864 * Les images naturelles sont décomposables en un ensemble de lignes de niveaux ( iso-niveau de gris ).
865 * Concevoir un algorithme GPU original et son implémentation.
869 LE FILTRAGE DES IMAGES
870 ======================
871 Filtre par recherche des lignes de niveaux
872 ------------------------------------------
876 * Estimation locale, par maximum de vraisemblance, des lignes de niveaux.
877 * Réduction de bruit par moyennage le long de la ligne estimée.
878 * Les lignes de niveaux estimées sont modélisées par des lignes brisées nommées **isolines**.
879 * Les segments des lignes brisées sont choisis parmi des motifs pré-établis (32 motifs).
882 .. image:: img/P5Q1.png
888 LE FILTRAGE DES IMAGES
889 ======================
890 Filtre par recherche des lignes de niveaux
891 ------------------------------------------
893 **Principe (étape 1)**
895 * En chaque pixel, recherche du motif maximisant la log-vraisemblance ( :math:`\(n=6, \sigma^2 =\)` variance )
899 $$-\frac{n}{2}log\left(2\pi\right) - \frac{n}{2}log\left(\sigma^2\right) - \frac{n}{2}$$
901 * Mémorisation des paramètres des motifs sélectionnés dans deux matrices :math:`\(I_{\Theta}\)` et :math:`\(I_{\Sigma}\)`.
903 .. image:: img/lniv-mv.png
908 LE FILTRAGE DES IMAGES
909 ======================
910 Filtre par recherche des lignes de niveaux
911 ------------------------------------------
913 **Principe (étape 2)**
915 * Allongement itératif des segments sous condition GLRT.
919 $$(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]$$
921 .. image:: img/pipd-detail.png
926 LE FILTRAGE DES IMAGES
927 ======================
928 Filtre par recherche des lignes de niveaux
929 ------------------------------------------
931 **Principe (étape 3)**
933 Compensation de la non robustesse de sélection des motifs dans les zones homogènes.
935 * identification des zones homogènes avec un détecteur de bords.
936 * Application d'un filtre moyenneur dans ces zones.
938 .. image:: img/detecteur.png
943 * Sous-ensembles de pixels n'ayant pas d'intersection --> MV
944 * Utilisation des motifs des segments pour gain de temps.
948 LE FILTRAGE DES IMAGES
949 ======================
950 Filtre par recherche des lignes de niveaux
951 ------------------------------------------
955 Sur l'ensemble d'images de S. Lansel (DenoiseLab, Université Stanford)
957 * Amélioration moyenne du rapport Signal sur bruit: **+7,1 dB**
958 * Indice de similarité structurelle : **+30%**
959 * Temps de calcul : **7 ms**
961 Comparaison avec BM3D
963 * Amélioration moyenne du rapport Signal sur bruit: **+9,5 dB**
964 * Indice de similarité structurelle : **+36%**
965 * Temps de calcul : **4300 ms**
969 LE FILTRAGE DES IMAGES
970 ======================
971 Filtre par recherche des lignes de niveaux
972 ------------------------------------------
976 ============================================ === ========================================
977 .. image:: img/zoom_noisy.png .. image:: img/zoom_mean5.png
980 Bruit gaussien :math:`\(\sigma=25\)` Moyennage 5x5
982 .. image:: img/zoom_pipdh.png .. image:: img/zoom_bm3d.png
985 ============================================ === ========================================
989 LE FILTRAGE DES IMAGES
990 ======================
991 Filtre par recherche des lignes de niveaux
992 ------------------------------------------
994 **Synthèse - conclusion**
996 * Rapport qualité/temps élevé.
997 * Traitement d'images HD à 20 fps.
998 * Artefacts en marche d'escalier. Réduits par la méthode de Buades *et al.* (+1 dB, +0,2 ms pour 512x512).
999 * Extension aux images couleurs et autres types de bruits (multiplicatif).
1000 * Algorithme original sans implémentation de référence séquentielle. Conception GPU dès l'origine.
1004 CONCLUSION GÉNÉRALE - PERSPECTIVES
1005 ==================================
1007 * Trois types de conception mis en |oe| uvre.
1008 * Le portage efficace d'algorithme peut s'avérer très complexe, voire sans intérêt.
1009 * L'emploi de la mémoire partagée n'apporte pas les meilleures performances en cas de recouvrements.
1010 * L'écriture de code performant est fastidieuse et les codes non paramétriques.
1011 * Création d'un programme générateur.
1013 * Beaucoup de traitements peuvent bénéficier des techniques proposées.
1014 * Les évolutions de l'architecture laissent entrevoir de nouvelles possibilités.
1015 * Extension à d'autres domaines.
1020 * certaines ardeurs ont été refroidies
1022 .. |oe| unicode:: U+0153
1025 .. |B| unicode:: U+00DF
