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.
133 * La segmentation représente aussi un enjeu crucial, mais aucun algorithme universel n'a encore été élaboré.
143 Traitements d'images de haut niveau
144 -----------------------------------
146 #. **Pré-traiter** et effectuer les traitements de haut niveau sur des images *améliorées*.
148 * réduction, *a priori*, du coût des traitements de haut niveau.
149 * les prétraitements ont eux aussi un coût, en temps de calcul et potentiellement en information.
151 #. **Ne pas pré-traiter** et effectuer les traitements de haut niveau sur les images bruitées.
153 * pas de perte d'information due au pré-traitement.
154 * les traitements de haut niveau sont, *a priori*, plus coûteux.
159 * 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.
166 Axes des travaux présentés
167 --------------------------
170 **Segmentation : accélérer le traitement de haut niveau**
172 * La segmentation consiste à identifier des zones homogènes dans une image.
173 * Algorithme de segmentation d'images bruitées par contours actifs, de la classe des *snakes*.
174 * Conception d'une implémentation avec adaptation de la technique d'optimisation.
176 **Filtrage : accélérer les pré-traitements**
178 Réduction de bruit additif gaussien, suivant deux méthodes de conception :
180 * algorithme original, conçu spécifiquement pour GPU, conjointement à son implémentation.
181 * algorithmes existants, où l'effort de conception ne peut porter que sur l'implémentation : filtres médian et de convolution.
192 * Nous nous sommes focalisés sur les *images naturelles* :
194 - réalisées en lumière naturelle, en intérieur ou en extérieur,
195 - prises avec un dispositif standard (CMOS, CCD).
197 * Les traitements que nous présentons ici opèrent sur des images en
198 niveau de gris (8 ou 16 bits).
202 * 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.
206 LA SEGMENTATION DES IMAGES
207 ==========================
208 Segmentation par contour actif
212 SEGMENTATION PAR CONTOUR ACTIF
213 ==============================
217 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 :
219 - La classe d'algorithmes la plus implémentée sur GPU est celle des **level-set**, essentiellement dans sa variante *bande étroite*.
220 - La classe des **snakes** n'est implémentée sur GPU qu'au travers la variante GVF (Gradient Vector Flow).
222 .. figure:: img/l7-gvf.png
225 À 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).
229 * Le domaine médical recèle la quasi totalité des implémentations GPU d'algorithmes de segmentation.
230 * Nombre d'entre elles concernent des traitements effectués en 3D par nécessité, où l'emploi du GPU s'impose assez naturellement.
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 * La référence est l'implémentation *snake GVF* de Smistad *et al.* qui parvient à segmenter des images d'IRM
257 - 2D, de 512x512 pixels, sur C2070, en **41 ms**.
258 - 3D, de 256x256x256 pixels, sur C2070, en **7151 ms**
260 .. figure:: img/brain3D-gvf.png
263 À gauche : une image 2D d'IRM. À droite : visualisation en 3D de la segmentation complète.
267 * À notre connaissance, aucune publication ne décrit d'implémentation de *snake* polygonal ou de *snake* orienté région.
271 SEGMENTATION PAR CONTOUR ACTIF
272 ===============================
273 *Snake* polygonal orienté région (principe)
274 -------------------------------------------
282 * - .. image:: img/snake-modele.png
284 - * L'objectif est de déterminer le contour le plus *vraisemblable* (nombre et positions des n |oe| uds).
285 * Le critère de vraisemblance généralisée est, dans le cas gaussien :
289 $$GL = \frac{1}{2}\left[ n_B.log\left(\sigma_B^2\right) + n_T.log\left(\sigma_T^2\right)\right]$$
291 * Les deux régions, intérieure et extérieure (T et B), sont prises en compte dans l'évaluation du contour.
292 * Les variances :math:`\(\sigma^2\)` doivent être calculées pour chaque état du contour, ce qui est **très coûteux**.
296 * Cela permet d'extraire des formes aux contours mal définis, en raison d'un fort niveau de bruit par exemple.
300 SEGMENTATION PAR CONTOUR ACTIF
301 ===============================
302 *Snake* polygonal orienté région (principe)
303 --------------------------------------------
305 .. image:: img/snake-modele.png
308 * Chesnaud *et al.* ont montré comment remplacer la sommation 3D par une **sommation 2D** le long du contour.
309 * Implique le **pré-calcul** des trois images cumulées
313 $$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$$
317 * 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.
321 SEGMENTATION PAR CONTOUR ACTIF
322 ===============================
323 *Snake* polygonal orienté région (algo CPU)
324 --------------------------------------------
326 .. image:: img/cochons-it0-it1.png
331 #. Le contour initial est rectangulaire ( 4 n |oe| uds )
332 #. 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.
337 SEGMENTATION PAR CONTOUR ACTIF
338 ===============================
339 *Snake* polygonal orienté région (algo CPU)
340 --------------------------------------------
342 .. image:: img/cochons-it21-it22.png
347 3. Ajout de n |oe| uds au milieu des segments suffisamment grands.
348 #. On recommence à évaluer les déplacements successifs des n |oe| uds.
352 SEGMENTATION PAR CONTOUR ACTIF
353 ===============================
354 *Snake* polygonal orienté région (algo CPU)
355 --------------------------------------------
357 .. image:: img/cochons-it4-it5.png
360 **Itérations 4 et 5**
364 SEGMENTATION PAR CONTOUR ACTIF
365 ===============================
366 *Snake* polygonal orienté région (algo CPU)
367 --------------------------------------------
369 .. figure:: img/im014.png
372 Image de 512x512 : contour final de 256 n |oe| uds en 14ms.
374 * 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)
378 SEGMENTATION PAR CONTOUR ACTIF
379 ===============================
380 *Snake* polygonal orienté région (algo CPU)
381 --------------------------------------------
383 .. figure:: img/snakegpu1.png
386 Image de 4000x4000 : contour final de 447 n |oe| uds en 700ms.
390 SEGMENTATION PAR CONTOUR ACTIF
391 ===============================
392 Parallélisation du *Snake* polygonal sur GPU
393 --------------------------------------------
394 Identification des fonctions coûteuses
396 .. image:: img/algosnake1.png
401 SEGMENTATION PAR CONTOUR ACTIF
402 ===============================
403 Parallélisation du *Snake* polygonal sur GPU
404 --------------------------------------------
405 Détail de la fonction de calcul du critère GL
407 .. image:: img/algosnake2b.png
413 SEGMENTATION PAR CONTOUR ACTIF
414 ===============================
415 Parallélisation du *Snake* polygonal sur GPU
416 --------------------------------------------
418 .. image:: img/snake-pairimpair.png
423 * 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.
424 * Pour éviter les oscillations et *coller* à l'algorithme séquentiel, on distingue les n |oe| uds d'indices pairs et impairs.
425 * On évalue **en parallèle** l'ensemble des déplacements éventuels de tous les n |oe| uds de même parité.
429 SEGMENTATION PAR CONTOUR ACTIF
430 ===============================
431 Parallélisation du *Snake* polygonal sur GPU
432 --------------------------------------------
434 **Structure des données** (n |oe| uds pairs)
436 .. image:: img/16segments.png
441 * règle 1 thread par pixel
445 SEGMENTATION PAR CONTOUR ACTIF
446 ===============================
447 Parallélisation du *Snake* polygonal sur GPU
448 --------------------------------------------
450 **Obtention du critère**
452 * Parallélisation : 1 thread par pixel.
453 * Une seule taille de segment : la taille du plus long.
454 * Bourrage avec des threads inactifs pour les segments plus courts.
455 * Calcul réalisé en 3 étapes par 3 fonctions parallèles GPU (*kernels*)
457 #. 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.
458 #. **Réductions** : calcul final des contributions des segments.
459 #. Calcul des valeurs du critère pour chaque contour évalué. Sélection du meilleur contour.
463 * les réduction consistent à sommer, pour chaque segment les contributions partielles par bloc calculées au 1
468 SEGMENTATION PAR CONTOUR ACTIF
469 ===============================
470 Parallélisation du *Snake* polygonal sur GPU
471 --------------------------------------------
473 **Propriétés de l'implémentation**
475 * Conservation des données en mémoire GPU.
476 * Les images cumulées sont calculées en parallèle.
477 * Abandon de l'algorithme de Bresenham pour la discretisation des segments.
478 * Trop peu de calculs à effectuer. Peu de threads dans la grille.
479 * Pas de coalescence possible dans les accès à la mémoire globale.
480 * Emploi de la mémoire partagée.
484 * Un seul entier est échangé entre le CPU et le GPU à chaque itération.
485 * image cumulées par une adaptation de la méthode des sommes de préfixes.
486 * Abandon Bresenham Possible car parcours unidirectionnel du contour.
487 * Trop peu de calculs ne permet pas de masquer les latences.
488 * Pas de coalescence possible dans les accès à la mémoire globale car la géométrie des segments varie.
489 * mémoire partagée à cause des réductions.
493 SEGMENTATION PAR CONTOUR ACTIF
494 ===============================
495 Parallélisation du *Snake* polygonal sur GPU
496 --------------------------------------------
498 **Performances de l'implémentation**
500 .. image:: img/perfs-snake.png
505 .. image:: img/perfs-snake-img.png
510 SEGMENTATION PAR CONTOUR ACTIF
511 ===============================
512 Parallélisation du *Snake* polygonal sur GPU
513 --------------------------------------------
517 * Première et seule implémentation à ce jour.
518 * Performances intéressantes pour les grandes images. 1OO MP en moins de 0,6 seconde.
519 * Temps de calcul très dépendant du contenu de l'image.
520 * Le GPU n'est pas employé de manière optimale : réductions, threads inactifs, non coalescence.
521 * Le GPU apporte un gain important sur les premières itérations, quand les segments sont grands.
522 * Initialisation optionnelle par maximum de vraisemblance. Accélération jusqu'à x15 avec de petites cibles.
526 LE FILTRAGE DES IMAGES
527 ======================
528 Filtre médian - Filtres de convolution - Filtre par lignes de niveaux
532 LE FILTRAGE DES IMAGES
533 ======================
539 LE FILTRAGE DES IMAGES
540 ======================
541 Filtre médian : principe
542 ------------------------
544 .. image:: img/median-principe.png
547 La valeur de sortie d'un pixel est la **médiane** des valeurs de son voisinage.
549 * Bonne réduction de bruits gaussien et *poivre & sel*
550 * Valeurs de sortie appartenant au voisinage.
551 * Opération de sélection coûteuse (tri).
552 * Usages fréquents avec des petites fenêtres (de 3x3 à 7x7).
553 * Quelques applications avec de grandes fenêtres (au delà de 21x21).
557 LE FILTRAGE DES IMAGES
558 ======================
559 Filtre médian : usage
560 ---------------------
564 =================================== ======================================== ============================================
565 .. image:: img/airplane_sap25.png .. image:: img/airplane_sap25_med5.png .. image:: img/airplane_sap25_med3_it2.png
566 =================================== ======================================== ============================================
567 Bruit *poivre & sel* 25% Médian 5x5 Médian 3x3 - 2 passes
568 =================================== ======================================== ============================================
572 LE FILTRAGE DES IMAGES
573 ======================
574 Filtre médian GPU : Travaux de référence
575 ----------------------------------------
577 * 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**) :
579 - **ArrayFire**, bibliothèque commerciale, débit max. **185 MP/s**
580 - **BVM** parallélisé par Kachelrie |B|, débit max. **110 MP/s**
582 .. image:: img/compar-median2.png
587 * PCMF : Parallel (Complementary Cumulative Derivative Function) Median Filter (histogrammes cumulatifs)
588 * CTMF : CPU à temps constant
592 LE FILTRAGE DES IMAGES
593 ======================
594 Filtre médian GPU : Travaux de référence
595 ----------------------------------------
597 Emploi de la **mémoire partagée** pour pré-charger les valeurs utiles à chaque bloc de threads.
599 .. image:: img/shmemhalo.png
604 LE FILTRAGE DES IMAGES
605 ======================
606 Optimisation du filtre médian GPU
607 ---------------------------------
609 Transferts des données optimisés
611 .. image:: img/CPU-GPU-memcpy.png
614 .. image:: img/transferts-mem.png
619 On gagne de 13 à 43 % sur les temps de transfert.
623 LE FILTRAGE DES IMAGES
624 ======================
625 Optimisation du filtre médian GPU
626 ---------------------------------
629 .. image:: img/CPU-GPU-memcpy-dummykernel.png
633 Débits maximums effectifs, en MP/s, pour des images en 8 et 16 bits, incluant les transferts optimisés (C2070).
635 .. image:: img/debit-max-2070.png
638 **Rappel :** PCMF : 80 MP/s - BVM : 110 MP/s - ArrayFire : 185 MP/s
642 ça laisse environ 80ms pour faire un tri de 9 valeurs sur une image de 4096x4096
646 LE FILTRAGE DES IMAGES
647 ======================
648 Optimisation du filtre médian GPU
649 ---------------------------------
651 **Sélection de la médiane**
653 * Emploi exclusif des **registres** pour charger les valeurs utiles.
654 * Limitations à 63 registres par thread et 32 K par bloc de threads.
655 * Envisageable pour les médians de petite taille (jusqu'à 7x7 avec 1 thread/pixel).
656 * Exploitation des recouvrements entre fenêtres de pixels voisins.
661 LE FILTRAGE DES IMAGES
662 ======================
663 Optimisation du filtre médian GPU
664 ---------------------------------
666 **Sélection de la médiane** (par oubli)
674 * - Bonnes performances envisagées :
676 * Économie de registres.
677 * Évite le tri complet.
678 - .. image:: img/forgetful_selection.png
683 LE FILTRAGE DES IMAGES
684 ======================
685 Optimisation du filtre médian GPU
686 ---------------------------------
688 **Exploitation des recouvrements**
690 .. image:: img/recouvrement5.png
693 **Intérêt :** Économie de registres - chaque thread traite 2 pixels.
697 * chaque thread utilise plus de registres
698 * mais sur un bloc, en adaptant la taille du bloc, on économise k+1 registres par paire de pixels.
702 LE FILTRAGE DES IMAGES
703 ======================
704 Optimisation du filtre médian GPU
705 ---------------------------------
707 **Masquage des latences**
709 * Accès à la mémoire globale : 2 pixels par thread.
710 * Instruction Level Parallelism (ILP) : Ordre des instructions minimisant l'interdépendance.
712 .. figure:: img/bitonic.png
715 Identification des extrema dans le vecteur initial d'un médian 5x5
719 * au delà de 2 pixels par thread, le gain sur les latences est compensé par la perte sur le calcul / niveau de parallèlisme.
720 * ILP maximisée en appliquant une méthode simple; utilisée par ex. dans la technique des réseaux de tri bitoniques.
724 LE FILTRAGE DES IMAGES
725 ======================
726 Performances du filtre médian GPU proposé (PRMF)
727 ------------------------------------------------
729 .. image:: img/perf-median.png
734 LE FILTRAGE DES IMAGES
735 ======================
736 Performances du filtre médian GPU proposé (PRMF)
737 ------------------------------------------------
741 .. image:: img/comp512.png
746 .. image:: img/comp4k.png
751 LE FILTRAGE DES IMAGES
752 ======================
758 * Pas d'utilisation de la mémoire partagée.
759 * Débit global amélioré de x7 à x10, proche du maximum.
760 * Débit de calcul atteignant **5,3 GP/s**.
761 * Médian jusqu'au 9x9 sur C2070, 21x21 sur K40.
762 * Création d'une application web générant les codes sources.
763 * Utilisé pour le pré-traitement d'images de cristallographie au synchrotron **SPring-8** (Japon).
765 .. image:: img/SPring8.png
770 LE FILTRAGE DES IMAGES
771 ======================
772 Les filtres de convolution
773 --------------------------
777 LE FILTRAGE DES IMAGES
778 ======================
779 Les filtres de convolution : généralités
780 -----------------------------------------
786 $$I_{out}(x, y) = \left(I_{in} * h\right) = \sum_{(i < H)} \sum_{(j < L)}I_{in}(x-j, y-i)h(j,i)$$
788 **Usage, selon les valeurs du masque h**
790 * réduction de bruit,
791 * détection de bords,...
795 * selon h --> convo séparable ou non séparable
799 LE FILTRAGE DES IMAGES
800 ======================
801 Les filtres de convolution GPU
802 ------------------------------
804 Le fabricant Nvidia propose la plus rapide des implémentations connue :
806 Convolution **non séparable** sur image de 2048x2048, masque h de 5x5, sur **GTX280**.
808 * Débit global : **945 MP/s**.
809 * Débit de calcul : **3,00 GP/s**
813 LE FILTRAGE DES IMAGES
814 ======================
815 Les filtres de convolution GPU
816 ------------------------------
818 Exploitation des recouvrements
820 * un seul accès mémoire par pixel, mémorisation en registre.
821 * mise à jour de tous les calculs concernés
823 .. image:: img/convoOverlap2.png
826 Application des techniques présentées pour le filtre médian :
828 * Optimum à 8 pixels par thread.
829 * Débit global : **966 MP/s**.
830 * Débit de calcul : **3,47 GP/s**
832 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)
836 LE FILTRAGE DES IMAGES
837 ======================
838 Les filtres de convolution GPU
839 ------------------------------
841 Convolution **séparable** sur C2070.
843 Implémentation Nvidia (mémoire partagée)
845 * Débit global max : **1933 MP/s**.
846 * Débit de calcul max : **6000 MP/s**
850 * Optimum à 8 pixels par thread.
851 * Une convolution 1D en mémoire partagée, l'autre en registres. Copie intermédiaire en mémoire globale (cache 1D rapide).
852 * Débit global : **2028 MP/s**.
853 * Débit de calcul : **7626 MP/s**
854 * Le gain est obtenu sur la convolution 1D en registres.
858 LE FILTRAGE DES IMAGES
859 ======================
860 Les filtres de convolution GPU
861 ------------------------------
865 * Amélioration limitée des débits globaux en raison de la prépondérance des temps de transfert.
866 * Amélioration sensible sur les débits de calcul (de 17 à 33 %).
867 * Le traitement 1D est jusqu'à 66% plus rapide. Applicable à d'autres signaux 1D.
871 LE FILTRAGE DES IMAGES
872 ======================
873 Filtre par recherche des lignes de niveaux
874 ------------------------------------------
878 LE FILTRAGE DES IMAGES
879 ======================
880 Filtre par recherche des lignes de niveaux
881 ------------------------------------------
885 * Les algorithmes qui débruitent le mieux sont lents (BM3D).
886 * Les images naturelles sont décomposables en un ensemble de lignes de niveaux ( iso-niveau de gris ).
887 * Concevoir un algorithme GPU original et son implémentation.
891 LE FILTRAGE DES IMAGES
892 ======================
893 Filtre par recherche des lignes de niveaux
894 ------------------------------------------
896 **Principe - modèle**
898 * Estimation locale, par maximum de vraisemblance, des lignes de niveaux.
899 * Réduction de bruit par moyennage le long de la ligne estimée.
900 * Les lignes de niveaux estimées sont modélisées par des lignes brisées nommées **isolines**.
901 * Les segments des lignes brisées sont choisis parmi des motifs pré-établis (32 motifs).
904 .. image:: img/P5Q1.png
910 LE FILTRAGE DES IMAGES
911 ======================
912 Filtre par recherche des lignes de niveaux
913 ------------------------------------------
915 **Principe (étape 1)**
917 * En chaque pixel, recherche du motif maximisant la log-vraisemblance ( :math:`\(n=6, \sigma^2 =\)` variance )
921 $$-\frac{n}{2}log\left(2\pi\right) - \frac{n}{2}log\left(\sigma^2\right) - \frac{n}{2}$$
923 * Mémorisation des paramètres des motifs sélectionnés dans deux matrices :math:`\(I_{\Theta}\)` et :math:`\(I_{\Sigma}\)`.
925 .. image:: img/lniv-mv.png
930 LE FILTRAGE DES IMAGES
931 ======================
932 Filtre par recherche des lignes de niveaux
933 ------------------------------------------
935 **Principe (étape 2)**
937 * Allongement itératif des segments sous condition GLRT.
941 $$(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]$$
943 .. image:: img/pipd-detail.png
948 LE FILTRAGE DES IMAGES
949 ======================
950 Filtre par recherche des lignes de niveaux
951 ------------------------------------------
953 **Principe (étape 3)**
955 Compensation de la non robustesse de sélection des motifs dans les zones homogènes.
957 * identification des zones homogènes avec un détecteur de bords.
958 * Application d'un filtre moyenneur dans ces zones.
960 .. image:: img/detecteur.png
965 * Sous-ensembles de pixels n'ayant pas d'intersection --> MV
966 * Utilisation des motifs des segments pour gain de temps.
970 LE FILTRAGE DES IMAGES
971 ======================
972 Filtre par recherche des lignes de niveaux
973 ------------------------------------------
977 Sur l'ensemble d'images de S. Lansel (DenoiseLab, Université Stanford), filtre proposé (PI-PD)
979 * Amélioration moyenne du rapport Signal sur bruit: **+7,1 dB**
980 * Indice de similarité structurelle : **+30%**
981 * Temps de calcul : **7 ms**
983 Comparaison avec BM3D
985 * Amélioration moyenne du rapport Signal sur bruit: **+9,5 dB**
986 * Indice de similarité structurelle : **+36%**
987 * Temps de calcul : **4300 ms**
991 LE FILTRAGE DES IMAGES
992 ======================
993 Filtre par recherche des lignes de niveaux
994 ------------------------------------------
998 ============================================ === ========================================
999 .. image:: img/zoom_noisy.png .. image:: img/zoom_mean5.png
1001 Bruit gaussien :math:`\(\sigma=25\)` Moyennage 5x5
1003 .. image:: img/zoom_pipdh.png .. image:: img/zoom_bm3d.png
1006 ============================================ === ========================================
1010 LE FILTRAGE DES IMAGES
1011 ======================
1012 Filtre par recherche des lignes de niveaux
1013 ------------------------------------------
1015 **Synthèse - conclusion**
1017 * Rapport qualité/temps élevé.
1018 * Traitement d'images HD à 20 fps.
1019 * Artefacts en marche d'escalier. Réduits par la méthode de Buades *et al.* (+1 dB, +0,2 ms pour 512x512).
1020 * Extension aux images couleurs et autres types de bruits (multiplicatif).
1021 * Algorithme original sans implémentation séquentielle de référence.
1025 CONCLUSION GÉNÉRALE - PERSPECTIVES
1026 ==================================
1028 * Trois types de conception mis en |~oe| uvre.
1029 * Le portage efficace d'algorithme peut s'avérer très complexe, voire sans intérêt.
1030 * L'emploi de la mémoire partagée n'apporte pas les meilleures performances en cas de recouvrements.
1031 * Filtres utilisables par tout programmeur grâce à un générateur de code.
1032 * Beaucoup de traitements et domaines peuvent bénéficier des techniques proposées.
1033 * Les évolutions de l'architecture laissent entrevoir de nouvelles possibilités.
1038 * certaines ardeurs ont été refroidies
1040 .. |oe| unicode:: U+0153
1043 .. |~oe| unicode:: U+0153
1047 .. |B| unicode:: U+00DF
