BE 2 – Mouvement

François Tassin / Guillaume Dutertre 1
BE 2 – Mouvement
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 2
BE 2 – Mouvement
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
de la vitesse sur des pixels voisins,
calcule la valeur.
est la valeur calculée de la vitesse par rapport à la moyenne
et ou l’indice k correspond au numéro de l’itération ou on
François Tassin / Guillaume Dutertre 3
BE 2 – Mouvement
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 4
BE 2 – Mouvement
%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 5
BE 2 – Mouvement
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 :
François Tassin / Guillaume Dutertre 6
BE 2 – Mouvement
On remarque que les vecteurs de déplacement respectent bien le déplacement général du cube
(rotation dans le sens anti horaire). On remarque également l’absence de vecteur (ou plus
exactement la nullité du déplacement) à la surface supérieure de la plate forme. En effet, celle-ci
étant uniforme, elle est considérée comme immobile.
Vidéosurveillance d’une rue
On utilise maintenant un extrait d’une bande de vidéosurveillance d’une rue sur laquelle on voit
passer un taxi. On obtient la figure suivante :
Comme pour le cube, le programme retranscrit bien le déplacement du véhicule. Par contre, on ne
voit pas le déplacement des deux véhicules sombres aux extrémités de l’image. En effet, l’algorithme
se basant sur la luminance, il n’y a que peu de changement d’intensité lumineuse dans ces régions
car les véhicules sont trop sombres.
François Tassin / Guillaume Dutertre 7
BE 2 – Mouvement
Zoom
On effectue un dernier test sur une image en « zoom ».
On observe que tous les vecteurs semblent partir du centre pour se diriger vers l’extérieur. C’est
l’effet produit par un zoom, il créé une singularité au centre.
Conclusion
A partir de l’équation du flux optique et de la condition d’ouverture, Horn et Schunck ont développé
un algorithme performant pour déterminer les vecteurs de déplacements dans une séquence
d’images. Ce BE nous a permis de mettre en évidence l’efficacité de l’algorithme à partir d’images
bien contrastées. En effet il est basé sur les variations de luminance des pixels pour déterminer les
vecteurs. Les limites de cette méthode pour le calcul des vecteurs ont été mises en évidence à
travers l’exemple du taxi et du cube en rotation mais en contrepartie on peut déterminer aisément le
mouvement réel qu’il y a eu à partir des tracés des vecteurs. Ainsi c’est une méthode efficace pour
réaliser une compression par compensation de mouvement.