COMPTE RENDU VISION PAR

ORDINATEUR

Estimation globale

Élèves :
Enseignants :
Maëlig BOUQUET DES
Frédéric BOUCHARA
CHAUX

30 mars 2025
Table des matières
1 Introduction 2

2 Restauration 2

3 Estimation du mouvement 5

4 Conclusion 9

1
1 Introduction
Dans ce TP, nous allons étudier les méthodes d’estimation globale avec deux algo-
rithmes : un algorithme de restauration et un algorithme d’estimation du mouvement. En
effet, ces deux algorithme sont fondamentaux pour la vision par ordinateur. Le premier
visera à améliorer la qualité d’une image bruitée et le second à détecter et quantifier le
déplacement des objets entres deux images successives.

2 Restauration
Dans cette partie, nous allons donc mettre en œuvre l’algorithme de récurrence de
restauration basé sur la méthode de Gauss-Seidel donné dans le cours par les formules
suivantes :

xk+1
i = xki + δik+1
avec :
(k+1) 1  
(k) (k) (k) (k)

δm,n = om,n − (1 + 4λ)x(k)
m,n − λxm+1,n − λxm,n+1 − λx m−1,n − λx m,n−1
1 + 4λ
En effet, dans cette formule, le λ servira de paramètre de lissage. Nous pourrons donc le
modifier à plusieurs reprises afin de voir la différence sur notre restauration d’image.

Description des étapes du codes :

1. Initialisation des données, importation de l’image et création de l’image bruitée :
Afin de pouvoir utiliser l’image, nous avons besoin de la convertir et normaliser avec
la fonction ’im2double’. Puis nous ajoutons un bruit gaussien centré par sigma.
1 clear ; clc ; close all ;
2 img_origin = im2double ( imread ( ' photophore . tif ') ) ;
3 sigma = 0.03;
4 img_bruit = img_origin + sigma * randn ( size ( img_origin ) ) ;

2. Algorithme de récurrence :
1 o = img_bruit ;
2 lambda = 1; % parametre de lissage
3 tol = 1e -4; % parametre d ' arret
4 iter = 0; % nb i t r a t i o n
5 [M , N ] = size ( o ) ;
6 x = o;
7 flag = 1;
8 while ( flag ==1)
9 x_old = x ;
10 delta_sum = 0;

2
 11

12 for m = 2: M -1
13 for n = 2: N -1
14 delta = (1/(1+4* lambda ) ) *( o (m , n ) -((1+4* lambda ) * x (m
, n ) ...
15 - lambda * x ( m +1 , n ) - lambda * x (m , n +1) - lambda * x (m -1 ,
n ) ...
16 - lambda * x (m ,n -1) ) ) ;
17

18 x (m , n ) = x_old (m , n ) + delta ;
19

20 delta_sum = delta_sum + abs ( delta ) ;

21 end
22 end
23 iter = iter +1;
24

25 if delta_sum < tol

26 flag = 0;
27 end
28 end

3. Evaluation des performances : Nous allons ensuite mesurée l’erreur quadratique

moyenne entre l’image d’origine et l’image restaurée par notre algorithme.
1 erreur = mean (( img_origin (:) - img_f (:) ) .^2) ;
2 fprintf ( ' erreur : ') ;
3 disp ( erreur ) ;

4. Pour finir, nous effectuons une comparaison avec un filtrage par convolution avec un
filtre de la moyenne :
1 flt = ones (3) ;
2 flt = flt / sum ( sum ( flt ) ) ;
3 img_f2 = conv2 ( img_bruit , flt , ' same ') ;
4 erreur2 = mean (( img_origin (:) - img_f2 (:) ) .^2) ;
5 fprintf ( ' erreur 2 : ') ;
6 disp ( erreur2 ) ;

Résultats :
Afin de bien se rendre compte des effets de notre algorithme, nous afficher les images
non bruitée, bruitée et restaurée :

3
 erreuralgo = 6.507774373458329e − 04
erreurconv = 1.355325848855640e − 03

Ici, nous pouvons observer que l’algo-

rithme de récurrence offre une meilleure
restauration en préservant mieux les dé-
tails de l’image.

Figure 1 – Résultats σ = 0.03 et

λ = 1.5

erreuralgo = 7.702575399073241e − 04
erreurconv = 1.533992278776619e − 03

Même en changeant le bruit sur l’image,

c’est l’algorithme de récurrence qui offre
une meilleure restauration de l’image.

Figure 2 – Résultats σ = 0.05 et

λ = 1.5

4
 erreuralgo = 7.957909028626626e − 04
erreurconv = 1.350916922911487e − 03

Lorsque nous changeons λ, nous obser-

vons que l’image est plus lisse et moins
"granuleuse". De plus, l’algorithme de
récurrence offre toujours une meilleure
restauration de l’image.

Figure 3 – Résultats σ = 0.03 et λ = 2

Nous pouvons ainsi conclure que pour la restauration d’image il est préférable d’ap-
pliquer l’algorithme de récurrence vu plus haut. En effet, il est plus efficace car il prend
en compte une régularisation spatiale qui permet une meilleure préservation des détails
de l’image. De plus, nous pouvons "jouer" sur le paramètre de lissage λ afin de diminuer
l’erreur ou de rendre l’image plus lisse.

3 Estimation du mouvement
Dans cette partie, nous allons donc mettre en œuvre l’algorithme de récurrence d’esti-
mation du mouvement basé sur la méthode de Horn Schunck donné dans le cours par les
formules suivantes :

uk+1
i = uki + δuk+1 , vik+1 = vik + δvk+1
avec
"  2 !
1 ∂om,n ∂om,n ∂om,n ∂om,n ∂om,n (k)
δu(k+1)
m,n = − − + 4λ u(k)
m,n − v
∂m ∂n m,n
2
∂om,n ∂m ∂t ∂m
∂m
+ 4λ
#
(k) (k) (k) (k)
+ λum+1,n + λum,n+1 + λum−1,n + λum,n−1

et
"  2 !
(k+1) 1 ∂om,n ∂om,n ∂om,n (k) ∂om,n ∂om,n (k)
δvm,n = − − + 4λ vm,n − u
∂m ∂n m,n
2
∂om,n ∂n ∂t ∂n
∂n
+ 4λ
#
(k) (k) (k) (k)
+ λvm+1,n + λvm,n+1 + λvm−1,n + λvm,n−1

5
En effet, cet algorithme va mettre à jour les champs de déplacement de u et v.

Description des étapes du codes :

1. Initialisation des données, importation des images et calcul des gradients via des
filtres de Sobel Gx et Gy : Afin de pouvoir utiliser les images, nous avons besoin
de les convertir et normaliser avec la fonction ’im2double’. Puis nous calculons les
gradients.
1 clear ; clc ; close all ;
2

3 img14_or = im2double ( imread ( ' street14 . tif ') ) ;

4 img15_or = im2double ( imread ( ' street15 . tif ') ) ;
5

6 Gx = [ 1 0 -1;
7 2 0 -2;
8 1 0 -1];
9 Gy = [1 2 1;
10 0 0 0;
11 -1 -2 -1];
12

13 dt = img15_or - img14_or ; % temps

14 conv_hor1 = conv2 ( img14_or , Gx , ' same ') ;
15 conv_hor2 = conv2 ( img15_or , Gx , ' same ') ;
16 dm = ( conv_hor1 + conv_hor2 ) /2; % horizontal
17 conv_ver1 = conv2 ( img14_or , Gy , ' same ') ;
18 conv_ver2 = conv2 ( img15_or , Gy , ' same ') ;
19 dn = ( conv_ver1 + conv_ver2 ) /2; % vertical

2. Algorithme de récurrence :
1

2 [M , N ] = size ( img14_or ) ;
3 lambda = 0.5;
4 iter = 0;
5 crit_arr = 1e -2;
6 delta_u = zeros (M , N ) ;
7 delta_v = zeros (M , N ) ;
8 u = zeros (M , N ) ;
9 v = zeros (M , N ) ;
10 flag = 1;
11 while ( flag == 1)
12 u_old = u ;
13 v_old = v ;
14 delta_sum_u = 0;
15 delta_sum_v = 0;
16

17 for m = 2: M -1

6
18 for n = 2: N -1
19 delta_u (m , n ) = (1/( dm (m , n ) ^2+4* lambda ) ) *( - dm (m , n ) *
dt (m , n ) -( dm (m , n ) ^2+4* lambda ) * u_old (m , n ) - dm (m , n )
* dn (m , n ) * v_old (m , n ) + lambda * u_old ( m +1 , n ) + lambda *
u_old (m , n +1) + lambda * u_old (m -1 , n ) + lambda * u_old (m
,n -1) ) ;
20 u (m , n ) = u_old (m , n ) + delta_u (m , n ) ;
21

22 delta_v (m , n ) = (1/( dn (m , n ) ^2+4* lambda ) ) *( - dn (m , n ) *

dt (m , n ) -( dn (m , n ) ^2+4* lambda ) * v_old (m , n ) - dm (m , n )
* dn (m , n ) * u_old (m , n ) + lambda * v_old ( m +1 , n ) + lambda *
v_old (m , n +1) + lambda * v_old (m -1 , n ) + lambda * v_old (m
,n -1) ) ;
23 v (m , n ) = v_old (m , n ) + delta_v (m , n ) ;
24 % delta_sum_u = delta_sum_u + abs ( delta_u ) ;
25 % delta_sum_v = delta_sum_v + abs ( delta_v ) ;
26 end
27 end
28

29 iter = iter +1;

30 if ( norm ( delta_u ) < crit_arr ) && ( norm ( delta_v ) < crit_arr )
31 flag = 0;
32 end
33 end

3. Sous échantillonnage : Nous allons ensuite sous échantillonner l’image afin de pouvoir
visualiser les flèches de mouvement correctement. En effet si nous ne le faisons pas,
nous aurons une flèche par pixel ce qui serait quasi invisible.
1 % sous echantillon
2 pas = 10;
3 [ x_grid , y_grid ] = meshgrid (1: M , 1: N ) ;
4 x_sub = x_grid (1: pas : end , 1: pas : end ) ;
5 y_sub = y_grid (1: pas : end , 1: pas : end ) ;
6 u_sub = u (1: pas : end , 1: pas : end ) ;
7 v_sub = v (1: pas : end , 1: pas : end ) ;

4. Pour finir, nous allons afficher la première image avec les flèches dessus à l’aide de
"quiver" :
1 figure ;
2 imshow ( img14_or ) ; % premiere image originelle
3 hold on ;
4 quiver ( x_sub , y_sub , u_sub , v_sub , 'g ') ; % affichage des
fleches
5 axis equal ;
6 title ( ' Champ de vecteurs de d p l a c e m e n t ') ;

7
 Résultats :
Nous obtenons donc l’image suivante avec les flèches de mouvement :

Figure 4 – Représentation des vecteurs de déplacement, λ = 0.5

Figure 5 – Représentation des vecteurs de déplacement, λ = 10

Sur ces deux images, nous pouvons voir la différence lorsque nous changeons la valeur de
λ. Effectivement, le paramètre λ va influencer le lissage spatiale du champ de mouvement.

8
Lorsque nous prenons un λ faible, notre champ de mouvement va être sensible au bruit
mais si nous prenons un λ plus élevé, notre champ de vecteurs sera plus régulier mais
atténueras les petits détails du mouvement.

Pour conclure, nous observons bien le mouvement de la voiture vers la droite ainsi que
le mouvement des nuages vers la gauche. Cependant, nous pouvons aussi déceler un léger
mouvement de la caméra vers la gauche avec un arrondi.

4 Conclusion
En conclusion, ce TP nous a permis d’implémenter et d’analyser deux algorithmes
essentiel dans le traitement de l’image. Le premier, l’algorithme de restauration nous a
montré qu’il avait de meilleurs résultats par rapport à un simple filtre de la moyenne. Puis
le second, l’estimation du mouvement a démonter des résultats cohérents et exploitables
en analyse sur deux images consécutives d’une vidéo.
En effet, ces techniques sont des atouts majeurs pour de nombreuses applications en
vision par ordinateur telles que la stabilisation vidéo et la reconnaissance des mouvement.