flot optique rapide sur grandes images par gpu et … · flot optique rapide sur grandes images par...
TRANSCRIPT
1
Champagnat et al. EEFTIG 1/7/10 – T1
Flot optique rapide sur grandes images par GPU et applications
Frédéric Champagnat, Guy Le Besnerais et Aurélien PlyerONERA/DTIM
Benjamin Leclaire, Yves Le SantONERA/DAFE
Ecole d’Été Francophone de Traitement d’Image sur GPU1er juillet 2010
Champagnat et al. EEFTIG 1/7/10 – T2
Plan
• Intérêt du GPU pour le traitement d’image
• Deux cadre d’illustration• Flot optique
• Introduction
• Méthodes locales : recalage de fenêtres• Passage au problème dense• Un schéma itératif rapide : FOLKI
• Implémentation GPU• Résultats
• Super-résolution• Définition• Shift-and-Add
• Implémentation GPU• Résultats
2
Champagnat et al. EEFTIG 1/7/10 – T3
Intérêt du GPU à l’ONERA
• Activité image : conception algorithmique• Capteurs aéroportés (en particulier: drone)
• Aide à l’autonomie (ego-motion, SLAM, flot optique)• Aide à l’interprétation de scène
• Détection, Tracking, Reconnaissance
• Contraintes d’embarquabilité
• Co-Conception de systèmes capteur/traitement• Prototypage pour mener des campagnes d’essai
• Approche « historique » : Matlab, C/C++• Pour plus de réalisme vis-à-vis cadences > 10fps : GPU
• Physique expérimentale et métrologie : utilisateurs• Grands moyens d’essai : génèrent masses de données• Accélérer le dépouillement des essais pour réduire le temps
d’immobilisation des souffleries
• Un réseau collaboratif : « l’Action de Recherche Fédératrice GPU »• Simulation numérique, traitement SAR…
Champagnat et al. EEFTIG 1/7/10 – T4
Plan
• Intérêt du GPU pour le traitement d’image à l’ONERA
• Deux cadre d’illustration• Flot optique
• Introduction
• Méthodes locales : recalage de fenêtres• Optimisation : globale ou itérative ?• Passage au problème dense
• Un schéma itératif rapide : FOLKI• Implémentation GPU
• Résultats
• Super-résolution• Définition
• Shift-and-Add• Implémentation GPU• Résultats
3
Champagnat et al. EEFTIG 1/7/10 – T5
=+=
),(0
)(
yA
yf
u
bz
Qu’est-ce que le flot optique ?
• Mouvement apparent des pixels
Champagnat et al. EEFTIG 1/7/10 – T6
• Block matchingZone de recherche
Mouvement optimal
Fenêtre recherchée
Estimation de mouvement : méthodes locales
4
Champagnat et al. EEFTIG 1/7/10 – T7
Méthode locale: corrélation
• Block matching : fenêtre recherchée
• Critère de recalage local (« correlation score »)
Score de corrélation J(u(k))
Zone de recherche
( )∑ −−−= 221 ))(()()())(( kumImIkmwkuJ
Champagnat et al. EEFTIG 1/7/10 – T8
Méthode locale: corrélation
• Block matching
• Critère de recalage local (« correlation score »)
Correlation score J(u(k))
Mouvement correctMouvement correctMouvement correctMouvement correct
Mouvement fauxMouvement fauxMouvement fauxMouvement faux Zone de recherche
( )∑ −−−= 221 ))(()()())(( kumImIkmwkuJ
5
Champagnat et al. EEFTIG 1/7/10 – T9
⇒ Problème d'optimisation non linéaire
• Block matching + algorithme de descente itératif • = LK algorithm [Lucas, Kanade, 1981]
Correlation score map
))((min )( kuku J
Maximisation de corrélation : approche itérative
u(0)
u(2)u(1)
Champagnat et al. EEFTIG 1/7/10 – T10
L' algorithme FOLKI
• Critère à minimiser en tout k:
Minimisation par fenêtre Conservation de l’intensité
6
Champagnat et al. EEFTIG 1/7/10 – T11
L' algorithme FOLKI
• Solution itérative d'estimation 'classique' u(k) ≈ u0(k) :
• Solution FOLKI utilisé u(k) ≈ u0(m) *:
* Le Besnerais & Champagnat, ICIP 05
Champagnat et al. EEFTIG 1/7/10 – T12
L' algorithme FOLKI
• Estimation s'en ramène à la résolution du système 2x2 :
• Où :
7
Champagnat et al. EEFTIG 1/7/10 – T13
Algorithme
• 1 Pour tout niveau de la pyramide
• 2 Calculer les gradients Ix et Iy de I1
• 3 Calculer la matrice H composé de Ix* Ix, Iy* Iy et Iy* Iy• 4 Convoluer les éléments de la matrice H par la f enêtre
• 5 Itérer :
• 6 Interpoler I2 par le déplacement estimé u
• 7 Calculer εεεε• 8 Calculer c en convoluant εεεε [ Ix, Iy] par la fenêtre w
• 9 Résoudre le système 2x2 en l'inversant
• 10 fin itération
• 11 fin pour
Champagnat et al. EEFTIG 1/7/10 – T14
• Pour tout niveau de la pyramide
• [Ix Iy] = gradient(I1,1);
• Ixx = conv2(Ix*Ix,W,'same');
• Ixy = conv2(Ix.*Iy,W,'same');
• Iyy = conv2(Iy.*Iy,W,'same');
• D = Ixx.*Iyy - Ixy.^2;
• for i=1:niter
• I2w = interp2(x+dx,y+dy,I2);
• S = I1 – I2 – Ix.*dx – Iy.*dy;
• C1 = conv2(S.*Ix,W,'same');
• C2 = conv2(S.*Iy,W,'same');
• dx = (C1.*Iyy – Ixy.*C2)./D;
• dy = (C2.*Ixx - Ixy.*C1)./D;
• end
• end
Algorithme (Octave/Matlab)
8
Champagnat et al. EEFTIG 1/7/10 – T15
• Pour tout niveau de la pyramide
• [Ix Iy] = gradient(I1,1);
• Ixx = conv2(Ix.*Ix,W,'same');
• Ixy = conv2(Ix.*Iy,W,'same');
• Iyy = conv2(Iy.*Iy,W,'same');
• D = Ixx.*Iyy - Ixy.^2;
• for i=1:niter
• I2w = interp2(x+dx,y+dy,I2);
• S = I1 – I2 – Ix.*dx – Iy.*dy;
• C1 = conv2(S.*Ix,W,'same');
• C2 = conv2(S.*Iy,W,'same');
• dx = (C1.*Iyy – Ixy.*C2)./D;
• dy = (C2.*Ixx - Ixy.*C1)./D;
• end
• end
Algorithme (Octave/Matlab)
pixel à pixel
convolution
interpolation
Idéal pour un GPU !Mais attention aux transferts CPU ↔ GPU
Champagnat et al. EEFTIG 1/7/10 – T16
Opérations pixel-à-pixel
• Opération « pur SIMD » (Single Instruction Multiple Data)
9
Champagnat et al. EEFTIG 1/7/10 – T17
Opérations pixel-à-pixel
• Solution simple :� 1 thread=1 atome de résultat• 3 étapes :1. Lecture des données de la
mémoire globale2. Opération3. Sauvegarde dans la mémoire
globale
__global__ fun_pap(float *in, float *out){
// calcul de la position du thread sur la donnéeInt position = threadIdx.x+dimBlock.x*blockIdx.x ;
// lecture de la donnéeFloat tmp_in = in[position] ;
// opération…
// sauvegarde du resultatout[position] = … ;
}
Int main(int argc, char ** argv){
Float h_in[N] h_out[N], d_in[], d_out[];cudaMalloc((void **)&d_in,sizeof(float)*N);cudaMalloc((void **)&d_out,sizeof(float)*N) ;cudaMemcpy(d_in,h_in,sizeof(float)*N,cudaMemcpyHost ToDevice)
;fun_pap<<<block,thread>>>(d_in,d_out) ;cudaMemcpy(h_out,d_out,sizeof(float)*N,cudaMemcpyHo stToDevice
) ;}
Champagnat et al. EEFTIG 1/7/10 – T18
Opérations pixel-à-pixel
__global__ fun_pap(float *in, float *out){
// calcul de la position du thread sur la donnéeInt position = threadIdx.x+dimBlock.x*blockIdx.x ;
// lecture de la donnéeFloat tmp_in = in[position] ;
// opération…
// sauvegarde du resultatout[position] = … ;
}
Int main(int argc, char ** argv){
Float h_in[N] h_out[N], d_in[], d_out[];cudaMalloc((void **)&d_in,sizeof(float)*N);cudaMalloc((void **)&d_out,sizeof(float)*N) ;cudaMemcpy(d_in,h_in,sizeof(float)*N,cudaMemcpyHost ToDevice)
;fun_pap<<<block,thread>>>(d_in,d_out) ;cudaMemcpy(h_out,d_out,sizeof(float)*N,cudaMemcpyHo stToDevice
) ;}
Code CPU (C/C++)
Code GPU (Cuda)
10
Champagnat et al. EEFTIG 1/7/10 – T19
Opérations de Convolution
• Opération avec dépendance locale de données (voisinage)• Gradients, Pyramides, Ondelettes, Morpho-Math
Champagnat et al. EEFTIG 1/7/10 – T20
Utilité de la shared memory
11
Champagnat et al. EEFTIG 1/7/10 – T21
Tuilage des données
Bloc de threadsThreads actifs
Threads servant seulement à lire les bords
Bloc d'image
Champagnat et al. EEFTIG 1/7/10 – T22
Opérations de Convolution
• Opération avec dépendance locale de données (voisinage)
__global__ fun_conv(float *in, float *out){
// calcul de la position du thread sur la donnéeint position = threadIdx.x+dimBlock.x*blockIdx.x ;float res;
// tableau de mémoire partagé commun à tout les thr eads d'un bloc
__shared__ float smem[K];
// lecture de la donnéesmem[threadIdx.x] = in[position] ;
__syncthreads() ; // syncronisation des threads du b loc
// opérationif(threadIdx.x>r && threadIdx.x<BlockDim.x-r){
res = 0;for(int ii=0 ; ii<K ; ++ii)
res = op(res,smem[threadIdx.x-r+ii]) ;
// sauvegarde du resultatout[position] = res ;
}}
12
Champagnat et al. EEFTIG 1/7/10 – T23
Interpolation
• Interpolation bilinéaire• Pré-cablée accessible à partir de la mémoire de texture• Précision des poids d’interpolation limitée
• Interpolation d’ordre supérieur (bicubique, B-spline…)• Pré-filtrage éventuel (B-spline)
• On se ramène à une succession d’interpolations bilinéaires [Ruijters06]
Gros avantage du GPU/CPU !
Champagnat et al. EEFTIG 1/7/10 – T24
FOLKI GPU contre FOLKI CPU
x100
• Pour de petites tailles de données, le GPU est pas exploité à 100%
• CPU utilisé Core2duo 8600• GPU utilisé GTX280• Pour une image 1920x1080, le
calcul du flot est inférieur à 40ms !
13
Champagnat et al. EEFTIG 1/7/10 – T25
Une application en métrologie : la PIV
Principe de formation d’images PIVCrédit : C. Brossard ONERA/DEFAhttp://www.aerospacelab-journal.org/fr/
Champagnat et al. EEFTIG 1/7/10 – T26
Application PIV: Sillages tourbillonnaires
1376x1040 crédit : J.-C. Monnier ONERA/DAAP
14
Champagnat et al. EEFTIG 1/7/10 – T27
Pyramides d’images : niveau 2
688x520
1376x1040
Champagnat et al. EEFTIG 1/7/10 – T28
Pyramides d’images : niveau 2
Level 1 :688x520Floor :1376x1040
Level 2 :344x260
15
Champagnat et al. EEFTIG 1/7/10 – T29
FOLKI_PIV: pyramid down ; level 2
344x260
Champagnat et al. EEFTIG 1/7/10 – T30
FOLKI_PIV: pyramid down ; level 2
344x260
16
Champagnat et al. EEFTIG 1/7/10 – T31
FOLKI_PIV: pyramid down ; level 1
688x520
344x260
Champagnat et al. EEFTIG 1/7/10 – T32
FOLKI_PIV: pyramid down ; level 1
688x520
344x260
17
Champagnat et al. EEFTIG 1/7/10 – T33
FOLKI_PIV: pyramid down ; floor
688x520
1376x1040
344x260
Champagnat et al. EEFTIG 1/7/10 – T34
FOLKI_PIV: pyramid down ; level 0
688x520
1376x1040
344x260
18
Champagnat et al. EEFTIG 1/7/10 – T35
Exemple PIV Haute Cadence
Crédit Benoît Gardarin
ONERA/DAFE/S19
1280x800
Traitement à 6 fps sur TESLA C1060
[Champagnat et al. PIV 2009][Leclaire et al. PIV 2009]
Champagnat et al. EEFTIG 1/7/10 – T36
Exemples de résultats
• Données test : cf. site Middlebury
• « Yosemite 2008 » : plus grand, plus beau et séquence réelle!
19
Champagnat et al. EEFTIG 1/7/10 – T37
Exemples de résultats
• Données test : cf. site Middlebury
• « Yosemite 2008 »
Champagnat et al. EEFTIG 1/7/10 – T38
Exemples de résultats
• Corrélation en télédétection (image IGN 2000x2000)• cadence vidéo sur GPU• Fenêtre gaussienne écart-type 4, pas de contrainte épipolaire
20
Champagnat et al. EEFTIG 1/7/10 – T39
Plan
• Intérêt du GPU pour le traitement d’image à l’ONERA
• Deux cadre d’illustration• Flot optique
• Introduction
• Méthodes locales : recalage de fenêtres• Optimisation : globale ou itérative ?• Passage au problème dense
• Un schéma itératif rapide : FOLKI• Implémentation GPU
• Résultats
• Super-résolution• Définition
• Shift-and-Add• Implémentation GPU• Résultats
Champagnat et al. EEFTIG 1/7/10 – T40
Super-Résolution : définition
• Exploitation de la redondance temporelle pour :• Réduire les effets d'alliasing (repliement du spectre),• Augmentation du rapport signal à bruit.
Zoom spatial Zoom spatio-temporel
Comment ?
21
Champagnat et al. EEFTIG 1/7/10 – T4141
Modèle de formation d’images
x +
v
y
b ∆
[ ] [ ]mmxmy kk ) )( ( +∗= b ∆ kv
Filtrage linéaire : flou
Echantillonnage : effets de crénelage
Bruit additif : aspect granuleux
Champagnat et al. EEFTIG 1/7/10 – T4242
Modèle de formation d’une séquence d’images
f
1y
2y ( ) ( )( ) 1 mxmx o=∆ ∆1f
[ ] ( )( ) [ ]mmxmy 11 +∗= b ∆ 1v
[ ] ( )( ) [ ]mmxmy 22 +∗= b ∆ 2v
( ) ( )( ) 2 mxmx o=∆ ∆2f
x +
v
y
b ∆
Conservation de la luminance
22
Champagnat et al. EEFTIG 1/7/10 – T4343
Modèle de formation d’une séquence d’images : translation
( ) ( ) 1 += mxmx ∆∆ 1τ
x
v
y
b ∆τ
[ ] ( )( ) [ ]mmxmy 11 +∗= b ∆ 1v
[ ] ( )( ) [ ]mmxmy 22 +∗= b ∆ 2v
( ) ( ) 2 += mxmx ∆∆ 2τLa SR exploite les
mouvements subpixelliques
+
1y
2y
Champagnat et al. EEFTIG 1/7/10 – T4444
Mise en œuvre
• Discrétisation :
• Matrice de transformation : interpolation de • Matrice de convolution : matrice de Toeplitz dépendant de
• Matrice d’échantillonnage : matrice creuse et binaire définie en fonction du facteur SR choisi
x +
v
y
b ∆f
kk vxy += kFBD
L
xb
23
Champagnat et al. EEFTIG 1/7/10 – T4545
• Connaissances a priori : • FEP du système • Le facteur SR
• Prétraitement :• Estimation des : recalage des images BR
Mise en œuvre
bL
• Modèle Elad & Feuer : [Elad et al., 1997] [Hardie et al., 1998]
Construction d’un système linéaire
Inversion régularisée
x̂Image SR
kk vxy += kFBD Images BR
Lbf , , ,y
kF
K=20 images 100x100
1 image SR 400x400
Système linéaire 200000x160000
• Remarque : • Un système linéaire de grande dimension et de structure complexe
Champagnat et al. EEFTIG 1/7/10 – T4646
Une alternative : le « Shift-and-Add »
Images BR
Image HR : « Shift-and-Add »Recalage dans une grille HR
Distribution non uniforme
[Elad & Hel-Or, 2001]
24
Champagnat et al. EEFTIG 1/7/10 – T4747
Interpolation : Shift & Add
Recalage
Images BR
Image de référence
Grille HR
Champagnat et al. EEFTIG 1/7/10 – T4848
Interpolation : Shift & Add
Recalage
Images BR Grille HR
Image de référence
Interpolation bilinéaireMoyenne Image
HR
• Approximations du Shift & Add :• Troncature des translations
• Interpolation bilinéaire des pixels sans valeur
Image HR avec des pixels sans valeur
Pixels àestimer
25
Champagnat et al. EEFTIG 1/7/10 – T4949
Recalage
Construction d’un système linéaire
Inversion régularisée
Image SR
Images BR
Shift-and-Add
Restauration
Image SR
Quelle rapport entre les deux approches ?
Equivalence sous certaines conditions [Létienne 2010]
=?
Champagnat et al. EEFTIG 1/7/10 – T50
Shift & Add et GPU
• Les pixels basse résolution sont projeté dans une grille haute résolution (écriture aléatoire ... ).
• Risque de collision → fonction atomic
Grille haute résolution
Grille basse résolution
26
Champagnat et al. EEFTIG 1/7/10 – T51
Super-Résolution sur GPU
1. Recalage : FOLKI2. Shift & Add3. Restauration par
filtrage de Wiener
Champagnat et al. EEFTIG 1/7/10 – T52
Application : imagerie IR
• Séquence d’origine (crédit : FLIR-ATS)
27
Champagnat et al. EEFTIG 1/7/10 – T53
Application : imagerie IR
• Séquence SR sur GPU
Champagnat et al. EEFTIG 1/7/10 – T54
Détails
Image brute (640x512) Image super-résolue
Cadence de sortie 10 fps sur TESLA 1060
28
Champagnat et al. EEFTIG 1/7/10 – T55
Séquence prise par réflex numérique
Image brute Image super-résolue
Champagnat et al. EEFTIG 1/7/10 – T56
Bilan
• Double intérêt du GPU• Algorithmie image et vision : prototype fonctionnant à des
cadences réalistes• Physique expérimentale :
• Accélération du dépouillement des campagnes de test• Meilleure utilisation des grands moyens d’essais
• Illustration sur deux familles algorithmiques• Flot optique :
• Traitement haute cadence de qualité métrologique• Outils en déploiement dans les souffleries de l’ONERA
• Super-résolution• Choix d’une méthode directe le Shift & Add• Prototype fonctionnant à 10 fps pour 640x512 sur TESLA 1060
• Plusieurs autres familles algorithmiques en réserve
29
Champagnat et al. EEFTIG 1/7/10 – T57
L’après EEFTIG
• Contacts : mailto:[email protected]
• Lien : http://www.onera.fr/dtim-en/gpu-for-image/index.php• Cette présentation• Références citées dans cette présentation
• Download du source de FOLKI-GPU (Linux/C++/CUDA)• Version plus complète bientôt à disposition
(Windows/C++/CUDA)
A vous de jouer !