Bonjour, j'essaye en ce moment d'implémenter l'algorithme de Lucas-Kanade (pour la détection du flux optique sur des images en niveau de gris). Seulement je dois m'y prendre particulièrement mal car j'obtiens des résultats très décevants

Pour info je m'inspire de cette page là pour l'implémentation :
http://en.wikipedia.org/wiki/Lucas%E2%80%93Kanade_method

Seulement tout n'est pas précisé sur cette page et j'ai pas mal de questions et de doutes :
1) Le (Vx, Vy) obtenu à la fin correspond-t-il bien au flux optique au point p ?
2) Le calcul de (Vx, Vy) doit-il être effectué pour chaque point de l'image ?
3) Actuellement pour le calcul de Ix (et de Iy) les dérivées partielles, soit P(x, y) le pixel aux coordonnées (x, y), si je suis en x = 0 je dis Ix = P(x + 1, y) - P(x, y), si je suis en x = width Ix = P(x, y) - P(x - 1, y), et sinon Ix = 1/2 * (P(x + 1, y) - P(x - 1, y)), est-ce que c'est la bonne méthode ?
4) Pour It, je prends ma seconde image P2 et ma première image P1 et je calcul It = P2(x, y) - P1(x, Y), c'est bon ?
5) Quelle forme et quelle taille doit-avoir la fenêtre autour du point p (ensemble {q1, ..., qn}) pour obtenir de bons résultats ?

mmm, j'y connais rien en vision

1) Le (Vx, Vy) obtenu à la fin correspond-t-il bien au flux optique au point p ?
Oui "the local image flow (velocity) vector (Vx,Vy)"

2) Le calcul de (Vx, Vy) doit-il être effectué pour chaque point de l'image ?
Oui le calcul est local en cahque point. Si tu veux une flux optique dense alors il faudra le calculer pour chaque pixel (ou alors faire de l'interpolation)

3) Actuellement pour le calcul de Ix (et de Iy) les dérivées partielles, soit P(x, y) le pixel aux coordonnées (x, y), si je suis en x = 0 je dis Ix = P(x + 1, y) - P(x, y), si je suis en x = width Ix = P(x, y) - P(x - 1, y), et sinon Ix = 1/2 * (P(x + 1, y) - P(x - 1, y)), est-ce que c'est la bonne méthode ?
Ix = (P(x,y) - P(x-1),y)
il s'agit d'un gradient basique d'intensité. Qui n'est pas valable pour la première ligne/colone de pixel.
Pour info, tu peux aussi utiliser des filtres de convolutions (prewit par exemple) pour calculer tes gradient directionels sur un plus grand voisinage.

4) Pour It, je prends ma seconde image P2 et ma première image P1 et je calcul It = P2(x, y) - P1(x, Y), c'est bon ?
oui, c'est la diférence d'intensité temporelle d'un meme pixel

5) Quelle forme et quelle taille doit-avoir la fenêtre autour du point p (ensemble {q1, ..., qn}) pour obtenir de bons résultats ?
Ca c'est la question a 1million d'euros.
En gros il n'y a pas de bonne réponse, ça dépend directement de la taille de tes mouvements entre deux images (en pixel). Information dont tu ne disposes pas a priori.

De plus comme expliqué dans le dernier paragraphe de la page wikipedia, cette méthode est basé sur une hypothèse de déplacements très petits (moins grands que les pixels) donc si tu lances directement cet algo sur deux frames successives de ta webcam ça va pas le faire. En général cette méthode est utilisée dans le cadre d'une approche multi-echelle (coarse to fine). C'est a dire que l'on construit une pyramide d'image de résolution de plus en plus faible (jusqu'a qq pixels de largeur). Cette méthode permet de retrouver les grands mouvement dans les images au niveaux de faibles résolution et de les propager lors du calcul des détails du déplacement aux résolution plus grandes.

L'implémentation de cet algo dans OpenCV utilise cette approche pyramidale.
http://opencv.willowgarage.com/documentation/cpp/video_motion_analysis_and_object_tracking.html?highlight=lk#calcOpticalFlowPyrLK

Ok donc finalement je n'étais pas si mal parti

Le principal problème étant que je fais mes tests sur deux frames sur lesquelles le mouvement des objets est en moyenne compris entre 5 et 10 pixels, si j'ai bien compris c'est beaucoup trop grand comme mouvement si on utilise pas une approche pyramidale.

Je vais essayer de trouver des documents sur le LK pyramidal pour pouvoir l'implémenter.

Mais sinon pour l'instant j'ai fait quelques tests et il y a un truc qui me paraît bizarre : plus j'augmente la taille de ma fenêtre (20x20 ou 30x30), plus mes vecteurs de flux optiques sont grands. Est-ce que c'est normal ou est-ce que ça veut dire que j'ai mal implémenté un truc, ou bien est-ce que ça vient du trop grand mouvement entre mes images qui rend l'algorithme inadapté ?

mmh je sais pas trop. Tu as biens tes poids wi qui somment a 1 ?

Ah bah non en fait
Je corrige ça, mais je sais pas trop si c'est ça qui pose problème, dans l'article Wikipédia il présente une version sans poids, ce qui revient à dire wi = 1, donc la somme des wi est forcément supérieure à 1 ?

Je crois que je vais relire tranquillement la bibliographie sur Lucas-Kanade parce que pour l'instant j'ai encore du mal à comprendre comment ça fonctionne

Avoir des poids qui somment a 1 ou pas te donneras la même solution ... modulo une multiplication par \sum(wi). En gros ça revient a multiplier A par une constante, ça change rien lors de la résolution, à part le résultat final
Ca explique pourquoi quand tu augmente la taille de ta fenêtre tu te retrouve avec une valeur de plus en plus grande.

Sinon il existe aussi la méthode de Horn & Schunck, qui est sans doute bien plus simple a mettre en oeuvre. Mais bon ça dépend de ce que tu veux faire (une methode de calcul de flow ou LK en particulier)
http://en.wikipedia.org/wiki/Horn%E2%80%93Schunck_method

Je crois que je vais regarder du côté de Horn & Schunk, le LK m'avait l'air pas mal mais il doit y avoir quelque chose qui cloche dans mon code et j'arrive pas à m'en sortir

En attendant j'ai aussi codé une méthode par block matching qui me donne des résultats plutôt satisfaisants (et qui me montre à quel point mon implémentation de LK doit être foireuse ).