Discussion :

[progfou]

Bonjour à tous !
J'aimerais bien mettre en oeuvre, dans le cadre d'un algorithme n'ayant pas de rapport avec la compression, un algorithme (rapide) d'estimation de mouvement.
J'ai bien sûr trouvé pas mal de doc à ce sujet, mais c'est la mise au point de l'algorithme qui me pose problème...

J'ai en entrée deux images, l'une étant la référence, l'autre l'image à "prédire".
Chacune des images est un tableau (de type unsigned char *, mais ce n'est pas la question), dont la composante (x,y) est calculée par :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

index = y*width + x

width étant bien sûr la largeur de l'image.

Mon problème principal est :
Comment copier dans un tableau (un vector en l'occurence) les MxM pixels constituant mon bloc, avec un algo (très) rapide ?
Je précise que je code en C++, mais je cherche l'algorithme, pas le code .

Merci d'avance de votre aide, je galère un peu...

[Graffito]

Bonjour,

J'ai envie de dire :
- Si les images ont des largeurs différentes, copier lignes par lignes par une copie de blocs mémoires (memcopy en C je crois)
- Si elles ont la même largeur, une seule copie mémoire suffit.

Mais, je ne suis pas sur d'avoir bien compris où était le problème.

[millie]

Comment copier dans un tableau (un vector en l'occurence) les MxM pixels constituant mon bloc, avec un algo (très) rapide ?

De plus, utilise l'option de compilation (fonctionne avec g++) : -O3 (pour les optimisations de vitesse maximale). Ca peut donner un coup de pouce.

[progfou]

Je précise :
Les blocs en question, de taille MxM, sont centrés en (x,y).
Donc, il me faut aller chercher les pixels dans l'image de référence de (x-M/2) à (x+M/2) et de (y-M/2) à (y+M/2).
Ensuite, je dois faire varier deux paramètres, qui sont les composantes d'un vecteur de déplacement (compris entre -w et +w, w entier), et aller chercher le bloc à l'emplacement [(x+wx), (y+wy)] dans l'image à estimer.

Une fois que j'ai ces blocs, il me faut faire une différence, et ça ne me pose pas de problème, mais c'est la copie de ces blocs qui me gêne !

[Graffito]

Bonjour,

Les pixels dans l'image de référence de la ligne j (avec j variant de y-M/2 à y+M/2) sont contenus dans des octets consécutifs du tableau, décalés par rapport au premier octet du tableau de (j*width+x-M/2)*size_of(Tab_item) et sur une longeur de M*size_of(Tab_item).

[progfou]

C'est quoi Tab_item ?
Tu peux expliciter ce que tu as essayé de dire ?

[Graffito]

Tab_item c'est un élément du tableau.
je suppose des unsigned char * [donc (sizeof(tab_item)=1], ce qui fait 256 couleurs seulement ou est-ce du noir et blanc avec un bit par pixel?

Si c'est du noir et blanc, il faut traiter séparement les octets de sur bords de la ligne.

[progfou]

En fait, j'ai tendance à faire un parcours du tableau en y, avec une boucle imbriquée pour les x, mais ça me semble très lourd.
Avec ce que tu as dit, je me dit, faire une boucle avec un memcopy, pourquoi pas...
On peut être plus rapide ?

[Graffito]

Y a pas grand chose à gagner sauf si c'est un bit par pixel et que w n'est pas multiple de 8.

[progfou]

Oups, je n'ai pas répondu, donc, c'est du 8 bits par pixels, et w, en général n'est pas multiple de 8.

J'ai une autre question de la même veine...
J'ai une matrice m'indiquant l'ordre dans lequel je dois traiter mes pixels, par exemple :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
D=[0 2
   3 1]

Comment je peux m'en servir dans mon programme ?

[Graffito]

0 2
3 1

A qoui correspondent les lignes et les colonnes ?

[progfou]

L'ordre dans lequel il faut prendre les pixels dans le bloc 2x2 (premier en haut à gauche, etc.).

[Charlemagne]

Je sais bien que la discussion date un peu.
Mais pour ceux que ça intéresse, j'ai mis en ligne mon code d'estimation de mouvement (très optimisé: MMX,SSE2,SSE3).
Attention à la licence GPL!

http://www.ient.rwth-aachen.de/team/...al/genial.html

La compilation de mon code C++ est un peu délicate, le plus simple pour les utilisateurs de Pentium 4 consiste à utiliser les fonctions correspondantes (Interface C) de la bibliothèque pré-compilée.