BE 2 – Mouvement

François Tassin / Guillaume Dutertre
BE 2 – Mouvement
1
BE – Mouvement
Sommaire
Objectifs .................................................................................................................................................. 1
Introduction ............................................................................................................................................. 1
Equation du flot optique ......................................................................................................................... 2
Algorithme de Horn et Schunck .............................................................................................................. 2
Principe ................................................................................................................................................ 2
Algorithme ........................................................................................................................................... 2
Implantation sous MATLAB ................................................................................................................. 3
Tests ........................................................................................................................................................ 5
Cube en rotation.................................................................................................................................. 5
Vidéosurveillance d’une rue ................................................................................................................ 6
Zoom .................................................................................................................................................... 7
Conclusion ............................................................................................................................................... 7
Objectifs
Les objectifs de ce bureau d’étude sont d’implémenter l’algorithme d’estimation du flot optique de
Horn et Schunk (contrainte en régularité) avec une méthode différentielle grâce au logiciel Matlab, et
à partir de tests sur différentes images de mettre en évidences les points évoqués dans le cours
correspondant
Introduction
Pour permettre un meilleur taux de compression, certaines normes (MPEG 2 par exemple) ne
calculent que quelques images compressées, les autres images elles sont compressées par la
méthode de compensation de mouvement : elles sont enregistrées sous forme de matrices de
vecteurs de déplacement calculés à partir des images complètes qui l’encadrent (on calcule le
mouvement de macroblocs ce qui diminue la quantité d’informations stockées).
Ces déplacements sont déduits du flot optique (gradient de la luminance) par une méthode
différentielle, et pour la résoudre on réalise des calculs approchés. Dans ce BE, nous implémenteront
l’algorithme d’estimation du flot optique, mais dans un premier temps, nous reviendrons sur les
aspects théoriques.

François Tassin / Guillaume Dutertre
BE 2 – Mouvement
2
Equation du flot optique
On considère que l’intensité de deux pixels voisins est très proche, et que celle-ci varie peut dans le
temps. On peut ainsi écrire (avec I l’intensité du pixel, repéré par sa position dans l’espace (x,y) et
dans le temps t ) :
On obtient ainsi l’équation du flot optique (en fait 2 équations scalaires) :
Cette équation doit nous permettre de calculer les termes 
,   et   qui correspondent aux
gradients spatiaux et temporel de la luminance.
Les gradients spatiaux correspondent à la différence d’intensité entre deux pixels voisins. De même,
le gradient temporel traduit la différence d’intensité, pour un pixel donné, entre deux images
successives. L’idée est de calculer la composante du mouvement dans la direction du gradient
d’intensité, en effet le mouvement correspond à une variation d’intensité (d’après l’hypothèse de
l’éclairement constant) donc on peut retrouver le mouvement partir de l’intensité lumineuse.
Cependant l’équation du flot optique comporte 3 inconnues donc on a un problème d’ouverture : il
faut imposer une condition supplémentaire, c’est pourquoi on utilise des méthodes de régularisation
telles que la méthode de Horn et Schunck.
Algorithme de Horn et Schunck
Principe
Pour la régularisation on minimise une fonction de coût (ou d’énergie) :
Dans cette équation :
-le premier terme correspond aux termes de l’équation du flot optique au carré
-λ est un facteur de pondération
-le deuxième terme correspond à la contrainte de régularité : on recherche les solutions les plus
régulières, c’est-à-dire que chacun des termes de l’équation soit le plus petit possible.
Algorithme
On propose alors le schéma itératif de résolution suivant :
Dans cette équation, sachant que  et  est la valeur calculée de la vitesse par rapport à la moyenne
de la vitesse sur des pixels voisins,  et ou l’indice k correspond au numéro de l’itération ou on
calcule la valeur.

François Tassin / Guillaume Dutertre
BE 2 – Mouvement
3
On souhaite avoir 
   et     (contrainte de régularité), ce qui correspond à    et
 . Donc pour choisir quand est ce qu’on arrête le calcul itératif, on utilise la norme suivante
qu’on va minimiser (condition de terminaison :   ) :
Implantation sous MATLAB
Voici le code tapé sous MATLAB pour utiliser cet algorithme :
function horn_schunck( im0, im1, eps )
%im0 et im1 les 2 images à comparer, eps la norme d'arret de la boucle.
close all
%on ferme toutes les fenetres
Im0=double(rgb2hsv(imread(im0,'bmp')));
Im1=double(rgb2hsv(imread(im1,'bmp')));
%lecture des 2 images bmp et conversion en hsv
I0=Im0(:,:,3);
I1=Im1(:,:,3);
%on ne conserve que la 3ieme composante, concernant l'intensité lumineuse
[M,N]=size(I0);
It=I1-I0;
%gradient temporel
Ix=zeros(M,N);
Iy=zeros(M,N);
for i=1:M-1
for j=1:N-1
Ix(i,j)=0.25*(I0(i,j+1)-I0(i,j)+I0(i+1,j+1)-I0(i+1,j)+I1(i,j+1)-
I1(i,j)+I1(i+1,j+1)-I1(i+1,j));
Iy(i,j)=0.25*(I0(i+1,j)-I0(i,j)+I0(i+1,j+1)-I0(i,j+1)+I1(i+1,j)-
I1(i,j)+I1(i+1,j+1)-I1(i,j+1));
end
end
%gradient spatial de la l'intensité lumineuse
Ix(M,:)=Ix(M-1,:);
Ix(:,N)=Ix(:,N-1);
Iy(M,:)=Iy(M-1,:);
Iy(:,N)=Iy(:,N-1);
%gradient spatial sur les bords (adaptés)
U=zeros(M,N);
V=zeros(M,N);
U2=zeros(M,N);
V2=zeros(M,N);
%U et V sont les composantes spatiales du champ de vecteur dé déplacement
%U2 et V2 serviront d'intermédiaires dans la boucle
lambda=0.1;
norme=1;
%initialisation de la valeur norme pour entrer dans la boucle
k=0;
%compteur
while (norme>eps)&&(k<50)

François Tassin / Guillaume Dutertre
BE 2 – Mouvement
4
%on limite à 50 itérations, on peut ainsi mettre eps=0 sans risque de durer
indéfiniment
for i=1:M
for j=1:N
if i==1
if j==1
u=0.5*(U(1,2)+U(2,1));
v=0.5*(V(1,2)+V(2,1));
elseif j==N
u=0.5*(U(1,N-1)+U(2,N));
v=0.5*(V(1,N-1)+V(2,N));
else
u=0.33*(U(1,j-1)+U(1,j+1)+U(2,j));
v=0.33*(V(1,j-1)+V(1,j+1)+V(2,j));
end
elseif i==M
if j==1
u=0.5*(U(M,2)+U(M-1,1));
v=0.5*(V(M,2)+V(M-1,1));
elseif j==N
u=0.5*(U(M,N-1)+U(M-1,N));
v=0.5*(V(M,N-1)+V(M-1,N));
else
u=0.33*(U(M,j-1)+U(M,j+1)+U(M-1,j));
v=0.33*(V(M,j-1)+V(M,j+1)+V(M-1,j));
end
elseif j==1
u=0.33*(U(i+1,1)+U(i-1,1)+U(i,2));
v=0.33*(V(i+1,1)+V(i-1,1)+V(i,2));
elseif j==N
u=0.33*(U(i+1,N)+U(i-1,N)+U(i,N-1));
v=0.33*(V(i+1,N)+V(i-1,N)+V(i,N-1));
else
u=0.25*(U(i-1,j)+U(i+1,j)+U(i,j-1)+U(i,j+1));
v=0.25*(V(i-1,j)+V(i+1,j)+V(i,j-1)+V(i,j+1));
%on calcule l'approximation du champ de vecteur à partir de l'itération
précédente
end
alpha=((Ix(i,j)*u+Iy(i,j)*v+It(i,j))/(1+lambda*(Ix(i,j)^2+Iy(i,j)^2)))*lamb
da;
U2(i,j)=u-alpha*Ix(i,j);
V2(i,j)=v-alpha*Iy(i,j);
%calcul des nouvelles valeurs de U et V à partir de l'approximation
calculée, corrigée par le terme alpha
end
end
norme=norm([U2 V2]-[U V]);
%calcul de la différence avec l'itération précédente
U=U2;
V=V2;
%affectation des nouvelles valeurs à U et V
k=k+1;
%le compteur d'itération augmente de 1.
end
for i=1:M
for j=1:N
if (rem(i,8)==0)&(rem(j,8)==0)
ua(i/8,j/8)=U(i,j);
va(i/8,j/8)=V(i,j);

François Tassin / Guillaume Dutertre
BE 2 – Mouvement
5
end
end
end
%cette étape permet de n'afficher qu'une partie des vecteurs (sinon le
champ de vecteur serait illisible)
figure,quiver(ua,va);
%on affiche le champ de vecteur (partiellement)
axis tight ij;
end
Ce programme renvoie donc le champ de vecteur de déplacement de l’image (partiel).
On teste ce programme avec différents couples d’images (on choisit deux images successives dans
une vidéo).
Tests
Cube en rotation
On teste le programme avec un cube en rotation, on fixe epsilon à 0 (le programme s’arrêtera alors
lorsque le nombre d’itération atteindra la limite fixée), voici la figure obtenue avec les 2 images
initiales :