Flot optique rapide sur grandes images par GPU et … · Flot optique rapide sur grandes images par...

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


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


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…


Plan

• Intérêt du GPU pour le traitement d’image à l’ONERA


• 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


=+=

),(0

)(

yA

yf

u

bz

Qu’est-ce que le flot optique ?

• Mouvement apparent des pixels


• Block matchingZone de recherche

Mouvement optimal

Fenêtre recherchée

Estimation de mouvement : méthodes locales

4


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


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


⇒ 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)


L' algorithme FOLKI

• Critère à minimiser en tout k:

Minimisation par fenêtre Conservation de l’intensité

6


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


L' algorithme FOLKI

• Estimation s'en ramène à la résolution du système 2x2 :

• Où :

7


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


• 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


• 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


Opérations pixel-à-pixel

• Opération « pur SIMD » (Single Instruction Multiple Data)

9



• 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

) ;}



__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


Opérations de Convolution

• Opération avec dépendance locale de données (voisinage)• Gradients, Pyramides, Ondelettes, Morpho-Math


Utilité de la shared memory

11


Tuilage des données

Bloc de threadsThreads actifs

Threads servant seulement à lire les bords

Bloc d'image


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


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 !


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


Une application en métrologie : la PIV

Principe de formation d’images PIVCrédit : C. Brossard ONERA/DEFAhttp://www.aerospacelab-journal.org/fr/


Application PIV: Sillages tourbillonnaires

1376x1040 crédit : J.-C. Monnier ONERA/DAAP

14


Pyramides d’images : niveau 2

688x520

1376x1040


Pyramides d’images : niveau 2

Level 1 :688x520Floor :1376x1040

Level 2 :344x260

15


FOLKI_PIV: pyramid down ; level 2

344x260



344x260

16



688x520

344x260



688x520

344x260

17


FOLKI_PIV: pyramid down ; floor

688x520

1376x1040

344x260



688x520

1376x1040

344x260

18


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]


Exemples de résultats

• Données test : cf. site Middlebury

• « Yosemite 2008 » : plus grand, plus beau et séquence réelle!

19



• Données test : cf. site Middlebury

• « Yosemite 2008 »



• 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


Plan

• Intérêt du GPU pour le traitement d’image à l’ONERA


• 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


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


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


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


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


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


• 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


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


Interpolation : Shift & Add

Recalage

Images BR

Image de référence

Grille HR


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


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]

=?


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


Super-Résolution sur GPU

1. Recalage : FOLKI2. Shift & Add3. Restauration par

filtrage de Wiener


Application : imagerie IR

• Séquence d’origine (crédit : FLIR-ATS)

27


Application : imagerie IR

• Séquence SR sur GPU


Détails

Image brute (640x512) Image super-résolue

Cadence de sortie 10 fps sur TESLA 1060

28


Séquence prise par réflex numérique

Image brute Image super-résolue


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


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 !

Flot optique rapide sur grandes images par GPU et … · Flot optique rapide sur grandes images par...

Documents

Transcript of Flot optique rapide sur grandes images par GPU et … · Flot optique rapide sur grandes images par...