Bonjour a tous.

Je suis actuellement en sup et mon Tipe consiste a simuler un freinage d'urgence.
Pour cela je vais créer une voiture en lego equipée d'une caméra; du moteur et des capteurs du Lego mindstorms.
Dans un premier temps je dois repéré les piétons ( ici des playmobil )
Et analyser si il y a une possibilité qu'il coupe la route du véhicule.
Le véhicule devrai donc freiner et s'arréter totalement si le piéton est trop près.

La 1ere partie concernant la détection de piétons est opérationnel par contre j'ai un probleme concernant le flux optique pour la seconde partie.

Je travaille donc sous python auquel j'ai ajouté numpy scipy PIL et pyopencv.

Je compte utilisé la fonction CaclcOpticalFlowLK de la bibliotheque pyopencv.
Cependant je ne comprend pas très bien comment l'utiliser.
En 1er argument je rentre mon image 1 en second l'image 2 et après je suis un peu perdu :/.
J'ai trouvé ceci:
http://www.siteduzero.com/forum-83-277 [...] e-webcam.html

( La partie qui m'intéresse se trouve le 27/05/2008 a 10h46:05)

Vers la fin du topic il utilise donc cette fonction mais sous C++
Et je cherche a faire la meme chose sous python.

Si quelqun pouvait m'éclairer se serait sympa

Salut.

OK on va détailler les arguments. La doc est là (c'est pas celle de pyopencv mais du binding python d'OpenCV, donc ça diffère peut-être un peu) : http://opencv.willowgarage.com/documen [...] opticalflowlk

Sinon, comme pyopencv reprend le principe de l'API C++ d'OpenCV, il faut peut-être jeter un oeil sur la doc C++, m'enfin les arguments auront de toute façon le même sens.

Image1 et Image2 c'est bon, c'est bien les images à l'instant t et à l'instant t + dt.

Ensuite tu as winSize.
Ce qu'il faut savoir c'est que dans le calcul du flot optique les pixels sont regroupés en régions pour déterminer le mouvement global de chaque région. Ici, c'est simplement la taille de la région (donc, (3, 3), (5, 5), etc...).

Pour velx et vely ce sont tes deux images de résultats, elles sont mono-canal, d'une profondeur de 32 bits (donc c'est des matrices de flottants), qu'il faut apparemment initialiser avant d'utiliser la fonction. velx va contenir en chaque pixel la composante du vecteur déplacement "en x", et vely, la même chose, sauf que c'est la composante "en y".

C'est plus clair comme ça ?

Merci de t'a réponse je vais regarder les doc et je te tien au courant


Si j'ai bien compris il faut initialiser velx et vely.

from pyopencv import *
from PIL import Image
velx=Image.new('c:\\imgnew.jpg',(320,240))
#(320,240) correspond a la taille de mon image capturé par la webcam

Cependant j'obtiens une erreur déja a ce stade la :/
Je vais continuer a chercher un peu de mon coté

Heu non si tu lui passes une PIL.Image il va pas apprécier.
Il faut lui passer une matrice pyopencv, normalement. Initialisée ne veut pas dire que c'est une image que tu as ouverte depuis un fichier, hein, ça veut juste dire que tu possèdes des références sur les images de résultat avant d'appeler la fonction.

D'accord je mettais inspirer de la fonction Createimage en c et j'avais penser que Image.new était l'équivalent sous python.
Et je l'avais en plus très mal utilisé.

Je vais donc chercher si je comprend bien a créer 2 matrices(velx et vely) de la meme taille que mon image initial afin que la fonction Calcopticalflowlk sache dans quoi enregistré les résultats.

Alors c'est à vérifier, mais étant donné que pyopencv reprend l'API C++ et qu'en C++ tu n'as besoin que de déclarer les variables genre « Mat velx, vely » (l'allocation se fait automatiquement lors de l'appel de la fonction en C++), t'as peut-être pas besoin de pousser les déclarations trop loin.

Merci pour tes réponses
j'ai essayer d'attribuer la classe "matrice" a velx et vely sans succes.
J'ai essayé avec numpy.array , numpy.mat mais aucun ne marche :/
J'ai essayé pas mal de chose mais je n'ai obtenu aucun résultat positif...

[Edit]
J'ai réussi a définir les matrice initial enfin jespere...

Cependant il y a encore un probleme

from pyopencv import *

img=imread("c:\\image1.jpg")
img2=imread('c:\\image2.jpg')

size = img.size()

velx=Mat(size, CV_32FC1)
vely=Mat(size, CV_32FC1)

calcOpticalFlowLK(img,img2,(7,7), velx, vely)

et j'obtiens l'erreur suivante:
Traceback (most recent call last):
File "C:\Python26\Lib\site-packages\xy\fluxoptique.py", line 33, in <module>
calcOpticalFlowLK(img,img2,(7,7),velx,vely)
ArgumentError: Python argument types in
pyopencv.cv_h_ext.calcOpticalFlowLK(Mat, Mat, tuple, Mat, Mat)
did not match C++ signature:
calcOpticalFlowLK(cv::Mat {lvalue} prev, cv::Mat {lvalue} curr, cv::Size_<int> win_size, cv::Mat {lvalue} velx, cv::Mat {lvalue} vely)

Je vous tien au courant si sa évolue.

Si ton image est en couleur il faut la convertir en niveau de gris avant. Il ne doit y avoir qu'un seul canal sur img et img2.

edit : j'ai un code qui marche, je poste ça dans quelques minutes.
edit2 : voilà le code

import cv

a = cv.imread("a.jpg")
a_gray = cv.cvtColor(a, cv.CV_BGR2GRAY)

b = cv.imread("b.jpg")
b_gray = cv.cvtColor(b, cv.CV_BGR2GRAY)

mx = cv.CreateMat(480, 640, cv.CV_32FC1)
my = cv.CreateMat(480, 640, cv.CV_32FC1)

cv.CalcOpticalFlowLK(a_gray,b_gray, (7,7), mx, my)

edit3: Juste dans mon code la taille de l'image est hard-codée, bien sûr il faut adapter...

Merci pour ta réponse
L'image que je capture est déja en niveau de gris lors de sa capture par la webcam. ( a moins que cela ne marche pas de capturer directement en niveau de gris et qu'il faille les convertir quad meme ?

Alors par contre pour le code je chercheais plutot une solution qui utilisait pyopencv.

Mais bon au pire je télécharge le module et j'utiliserais ton code.

Encore merci

Ah désolé, je ne savais même pas qu'il y avait plusieurs bindings pour opencv. J'ai utilisé le "officiel". Je vais essayer rapidement avec celui là voir si j'arrive à quelque chose. Je te tiens au courant.

À mon avis, contrairement à ce que j'ai déjà pu dire sur ce forum il y a un bout de temps, il vaut mieux effectivement utiliser le binding "officiel" d'OpenCV pour Python, qui s'est largement amélioré depuis le temps, et qui contrairement à pyopencv, est maintenu par une grosse communauté.
D'ailleurs, pyopencv ne tire pas autant parti des nouvelles possibilités d'OpenCV 2.2 que le binding officiel.

Sinon, non. Quand tu captures une image depuis la webcam, celle-ci est nécessairement en format "8UC3", c'est-à-dire 3 canaux (B, G, R) codés sur 1 octet chacun. Il faut donc que tu la convertisses, avec par exemple cv.CvtColor.

Même si l'image que je capture a l'aide de la webcam est déjà en niveau de gris il faut que je la reconvertisse ?? ( (je capture en niveau de gris a l'aide d'une option de la webcam car l'image prend moins de temps a être traité après et je ne perd pas d'information importante)

En tout cas il faut que tu le vérifies.

Je me suis décidé donc a passer sur opencv.

J'ai télécharger opencv2.0 et j'ai copié les contenu du sous dossier python2.6 dans le logiciel python (2.6).

Cependant sa ne fonctionne pas .

Si qqn pouvait m'indiquer ce qu'il fallait faire se serait sympa.

De meme avec opencv2.1 :/
J'obtiens l'erreur suivante après avoir tapé: Import opencv

Traceback (most recent call last):
File "C:\Python26\Lib\site-packages\xy\affvideo.py", line 9, in <module>
import opencv
File "C:\Python26\lib\site-packages\opencv\__init__.py", line 74, in <module>
from cv import *
File "C:\Python26\lib\site-packages\opencv\cv.py", line 25, in <module>
_cv = swig_import_helper()
File "C:\Python26\lib\site-packages\opencv\cv.py", line 21, in swig_import_helper
_mod = imp.load_module('_cv', fp, pathname, description)
ImportError: DLL load failed: Le module spécifié est introuvable

Tu es sûr que les librairies d'opencv sont bien accessibles ? Et qu'il n'y avait rien à compiler ? Enfin après je ne sais pas j'ai jamais essayer d'utiliser opencv sous Windows.