TIPE:Motion Capture besoin d'aide

[invitea4a5c45a]

Voilà je suis en 2ème année de prépa option MP et j'ai décidé d'axer mon TIPE de cette année sur la Motion Capture.
Actuellement je pense avoir compléter la partie "bibliographie" de mon TIPE, à savoir présentation et description des différents types de motion capture, ainsi qu'un sujet d'ouverture (ou plutôt un procédé de motion capture récemment développé).

Cependant, j'ai encore quelques doutes concernant mon TIPE (je précise que je travaille seul alors je me sens bien démuni et désavantagé ).

Tout d'abord, est-ce que je devrais approfondir chaque type de motion capture que je présente (ce que je fais pour chacune d'elle, c'est présenter globalement le principe et citer les avantages et inconvénients par rapport aux autres types de motion capture) ? Parce que je n'ai pas vraiment l'impression d'utiliser les connaissances acquises pendant mes 2 années de prépa (pas de calculs,pas de formules scientifiques, ce n'est pour l'instant qu'une sorte d'exposé compréhensible par n'importe qui).
Mais bon je ne vois pas trop comment approfondir...

Ensuite vient la grosse question (inquiétude?) concernant la "valeur ajoutée".
Que pourrais-je bien apporter au sujet ? Je ne peux quand même pas inventer un nouveau type de capture de mouvement !
J'ai trouvé sur le net un tuto pour faire de la motion capture maison avec After Effects, mais 1)ce n'est pas vraiment de la "valeur ajoutée" puisque ce n'est pas moi qui ai inventé cette méthode; 2)Partir d'un logiciel comme After Effects,et en plus d'un tuto réalisé par quelqu'un d'autre, ça ne paraît pas un peu trop facile et paresseux ? ...

Voilà donc jusque là comme vous pouvez le constater je n'ai pas fait grand chose (et cela m'inquiéte je me sens largué et "anormalement à la bourre").
Pourriez-vous m'éclairer sur mes doutes et peut-être me donner des conseils quant à la "valeur ajoutée" que je pourrais apporter s'il vous plait ?
Je vous remercie d'avance pour vos futures réponses (et pour avoir eu le courage et la bonté de vous taper le pavé que je vous ai pondu ).
-----

[inviteabd566ec]

Bonjour,

en effet il te faut clairement une valeur ajoutée, un simple exposé (surtout vulgarisé) ne suffit clairement pas pour un TIPE de prépa (désolé ...). Par contre il me semble tout à fait possible de faire ta propre plate-forme de motion capture (à condition de ne faire que de la capture par imagerie, parce que après ça se complique niveau expérimental). Il te suffit en fait de filmer le cobaye (muni de senseurs, genre juste des balles de ping pond peinte d'une couleur bien visible, c'est à dire pas couleur peau ni couleur vêtements) avec 2 cameras (ça doit se trouver ça), de transférer les données sur un ordi, d'en extraire la position des capteur par un petit traitement d'image, d'en extraire les positions des capteurs dans l'espace réel. Après une fois que t'as ça tu peux peut être juste t'en tenir à un bonhomme en "fil de fer", c'est déjà un début. Déjà c'est pas mal, tu as de l'expérimental, de la programmation (le traitement des images peut totalement se programmer "à la main", il faut juste faire dans un premier temps la conversion des vidéos dans un format non compressé), des calculs (parce que extraire la position d'un point à partir d'une image c'est plus coton que ça en a l'air *) ... Donc moi ça me semble une bonne piste de valeur ajoutée (et en plus ça peut être marrant à faire, quoi demander de plus !).

Voila, bon courage.

* : J'avais fait un document là dessus pour une personne qui voulait utiliser ce genre de technique dans son métier, si ça t'intéresse je peux te l'envoyer, ça peut donner des pistes.

[invitea4a5c45a]

Merci pour ta réponse Franzzzzzzzz .
Donc oui pour le TIPE type exposé je m'en doutais merci de confirmer ^^.
Donc si j'ajoute à ce que j'ai déjà fait (le peu que j'ai fait xD ...) de la motion capture maison ça devrait suffire à élever mon pseudo-exposé au rang de véritable TIPE ? Ou faut-il que j'approfondisse aussi la partie théorique (même si je vois pas quoi mettre de plus ^^) ?

Le problème que par contre (que j'ai déjà évoqué dans mon premier post), c'est que le tuto pour la motion capture expérimentale que j'ai trouvé me permettrait effectivement d'enrichir mon TIPE (il y a même les codes de programmation et les manips à entrer) mais le hic c'est qu'il n'est pas de moi ... Alors même si ça me demandera des efforts (fabriquer les capteurs, suivre la programmation ...) ça ne sera pas vraiment de la valeur ajoutée non ?

Sinon ça me dirait bien de tenter de la motion capture maison par mes propres moyens (j'entends pas cela sans le tuto cité ci-dessus) mais je m'y connais peu en programmation (et en informatique en général) ... Cela dit s'il existe des tutos et des programmes pour m'aider (je sais pas, un programme permettant de restituer dans un espace virtuel un point dont les coordonnées sont définies par des calculs effectués à partir d'une video par exemple...) je peux tenter ma chance (j'ai soif d'apprendre !)...

Donc si tu peux me fournir des tutos,des logiciels ou des pistes pour me lancer dans l'expérience ("extraire la position des capteurs par un petit traitement d'image","programmer à la main le traitement d'images",etc...) n'importe quoi qui me serait utile (même si ça traite des bases, considère que je n'en ai pratiquement aucune (de base en programmation)) je t'en serais extrêmement reconnaissant ^^ (même si ça demande beaucoup de travail je tenterais).

Voilà j'attends avec impatience ta réponse (et d'autres réponses aussi X3 ).

PS: Concernant ton document, je veux bien y jeter un oeil. Pourrais-tu l'uploader (sur megaupload par exemple) stp ?

PS-2: Concernant le tuto de mo-cap dont je parle depuis le début, voilà le lien (si ça peut aider à mieux comprendre ma situation/mon dilemne xD) : http://kruty.biiim.com/index.php?200...-after-effects .

[inviteabd566ec]

Bonjour,

si tu parviens à la motion capture maison, ça me semble déjà pas mal. Après, si t'as le temps d'approfondir la théorie (peut-être du côté de la motion capture pas par prise de vue mais par induction etc.), ça ne pourra pas t'être reproché ! Mais il me semble que dans un TIPE l'expérience est plus importante que la théorie (mais attention, ce n'est que mon humble avis ! ).
Pour le tutoriel que tu as trouvé, effectivement il donne vraiment tout ce qu'il faut. Tu peux t'en inspirer, en particulier pour la partie acquisition (balles réflechissantes ... (même si personnellement je trouve plus simple de travailler sur les couleurs mais bon ...) ). Par contre, je pense qu'il faut que tu programme toi-même ton truc : même s'il est pas parfait, c'est toi qui l'aura fait, ça se verra et se sera bien ! (Et puis je suis déçu quand même, un MP qui sait pas programmer ... ).

je sais pas, un programme permettant de restituer dans un espace virtuel un point dont les coordonnées sont définies par des calculs effectués à partir d'une video par exemple...

En fait pour moi c'est là qu'a lieu la valeur ajoutée. Donc je pense que c'est là qu'il va falloir programmer (et en plus je connaîs pas de logiciel qui font ça). Si tu veux, je peux t'aider dans ta programmation, y'a pas de problème. Je te conseillerais de programmer en C, à mon avis c'est le plus simple pour commencer et c'est largement suffisant pour ce que tu veux faire. Vraiment à mon avis c'est tout à fait faisable dans les temps, en commençant maintenant.

Donc à mon avis, dans l'ordre :
- Tu lis le document que je t'envoie, essaye de vérifier les calculs etc.
- Tu réflechis à la structure du programme (cf après).
- Tu prends un bouquin d'introduction au langage C et t'y vas !
- Tu commence par tester ton programme sur une seule image que tu créé genre avec gimp, pour voir si ton programme est capable de détecter genre un gros pâté vert sur fond blanc (commence pas avec des vrais images).

Pour le programme, il faut voir que quand tu auras branché la caméra sur ton ordinateur, tu auras un fichier genre AVI. Tu commenceras par le convertir en un fichier brut (plus de compression), avec imageJ (je pense qu'il le fait). Tu as alors un fichier où les 800*600*3 premiers octets représentent la première image, les 800*600*3 octets la seconde (c'est à dire largeur en pixel fois hauteur en pixel fois 3 parce qu'il y a trois couleurs primaires) etc. L'avantage est que maintenant les images peuvent être lues directemen en C : un tableau à 2 dimensions pour chaque couleur et chaque image, une condition "if " pour tester tous les pixels et voir lesquels sont de la couleur de tes balles. Tu as alors les coordonnées dans les images de tes capteurs. Tu utilise le doc que je t'envoie pour les convertir en position réel, et tu as déjà fait un grand pas !

Bon, je ne sais pas si c'est très clair, mais je répète que vraiment ça me semble tout à fait faisable, et "marrant" en plus (et comme je te l'ai déjà dit je peux t'aider pour le code et tout ça).

Bon courage !

Fichier : http://dl.ens-lyon.fr/bigfilesharing...a/Document.pdf

[A voir en vidéo sur Futura]

[invitea4a5c45a]

Lut,
merci pour ta réponse rapide et le temps que tu accordes à ma situation Franzzzzzzzz .
Je vais de ce pas lire le document que tu m'a donné et suivre tes différentes étapes !

Sinon (désolé si je vais te paraître très inexpérimenté dans le domaine) qu'est-ce que le C ? Quel programme faut-il pour "programmer en C" ? Le seul que je sache suffisamment utiliser,c'est Maple .
Tu parles de (je cite) "tableau à 2 dimensions pour chaque couleur et chaque image, une condition "if " pour tester tous les pixels et voir lesquels sont de la couleur de tes balles. Tu as alors les coordonnées dans les images de tes capteurs" , pourrais-tu préciser (encore plus parce que tu le fais bien mais jsuis assez dur à la comprenette concernant ce domaine ^^ ) stp ?
Si je suis toutes tes étapes (actuelles), cela me mènera à un programme restituant les mouvements de point dans un espace virtuel en 2D ou en 3D ? Si seulement 2D, penses-tu que ça sera suffisant comme valeur ajoutée pour mon TIPE (bien sûr, même si oui, je tenterai d'étoffer encore plus ... Le fait d'écrire moi-même un programme m'enthousiasme déjà beaucoup ) ?

Pour le moment je vais me plonger dans ton document et commencer à essayer de percevoir (note ma relative confiance en moi ^^) la structure du programme (par programme, entends-tu des boucles if,do,des procédures,etc... comme on en rencontre dans Maple ?) .


PS: Et oui un MP qui sait pas programmer !
Disons que quand je vais sur mon pc c'est plutôt pour jouer (je suis trop faible d'esprit et narrow-minded ^^!).
Je suis plutot doué pour les études, disons sur le papier quoi ( Un élève studieux qui joue aux jeux vidéos on aura tout vu xD !).

[inviteabd566ec]

Bonjour,

le C, c'est un langage de programmation, c'est à dire en quelque sorte un moyen de communiquer avec son ordinateur. On peut faire le parallèle avec le langage maple : les 2 permettent de programmer son ordinateur. En revanche, un programme Maple aura besoin du logiciel Maple pour pouvoir fonctionner, alors qu'un programme écrit en C n'aura besoin de rien d'autre pour fonctionner ensuite. Il y a cependant une contrepartie : une fois écrit son code source (càd le code plein de for, if ...), il est nécessaire de transformer ça en un code compréhensible par la machine : c'est l'étape de compilation (et d'édition de lien, c'est pas tout à fait la même chose mais passons). Un autre avantage du C, c'est qu'il permet de manipuler simplement les fichiers (càd lire des octets, lire des bouts, en écrire d'autres) ce que ne fait pas Maple à ma connaissance. De plus, je trouve personnellement le C plus simple à utiliser et plus clair que Maple, mais après chacun ses goût.
Pour programmer en C, je te conseille le logiciel Dev-C++, qui a mon avis est assez simple à utiliser pour commencer : il te permet d'écrire ton code source avec la coloration syntaxique (les for ne sont pas écrit de la même couleur que le reste par exemple), et il suffit de cliquer sur une icône pour compiler.

Pour être plus clair, je te donne la structure type du programme :

- Ouverture de la vidéo
+ Boucle sur les images
   - Lecture de l'image => placé dans 3 tableaux : rouge[lignes][colonnes], vert[lig][col], bleu[lig][col]
   + Boucle sur les lignes de l'image (i indice de la boucle)
       { Boucle sur les colonnes (j indice de la boucle)
            SI rouge[i][j]=0 ET vert[i][j]=255 ET bleu[i][j]=0 ALORS on vient de trouver un capteur.
       } Fin de boucle colonne
   } Fin de boucle ligne
} Fin de boucle sur les images.

Note que cela n'est PAS DU TOUT du C (c'est du plus ou moins pseudo algorythmique ...). J'ai considéré ici que tes capteurs étaient vert pur (codage des couleurs de 0 à 255). Tu remarque plusieurs problèmes qu'il y aura à résoudre :
- Il vaudra plutôt donner un intervalle de couleurs admissible plutôt qu'une seule couleur (facile)
- Il faudra détecter tout le capteur et ensuite en déduire sa position (he oui, plusieurs pixels composeront le capteur ! ) (moins facile ! ).

Pour la structure du programme, comme tu le vois ça ressemble à du Maple. En fait tous les langages se ressemblent, au moins pour les bases. Il suffit de connaître les variables (et les moyens de les modifier), les boucles (for, while) et les instructions conditionnelles (if, else) ; et il est alors possible de programmer (en très gros traits quand même).

A la fin, si tu suis le doc que je t'ai fourni, c'est bien du 3D que tu auras(si tu utilises 2 caméra).

Tu peux déjà commencer à ébaucher la première partie du programme (en gros celle que j'ai ébauchée là haut), le doc ne sert pas pour celle là, c'est vraiment de la programmation pure. Essaye de voir pour détailler complètement la structure de cette partie et on en discutera.

[invitea4a5c45a]

La première partie du programme ( c'est-à-dire avec les tableaux) elle consiste à analyser la vidéo image par image (vu qu'elle aura été transformée par imageJ) et sur chaque image, je teste chaque pixel (indexé par le couple (i,j)) et je regarde s'il correspond à la couleur de mes capteurs ( avec par exemple SI rouge[i,j]=0 ET bleu[i,j]=0 ET 200<vert[i,j]<255 ALORS... ) si j'ai bien compris ^^.
En gros, à l'issue de cette première partie j'aurai la position de chaque capteur sur un plan 2D sur chaque image,et donc si je compile les images j'aurai les mouvements des capteurs dans le plan 2D c'est ça ?

Si déjà ce qui est écrit au-dessus est juste, alors c'est que j'ai globalement saisi la première partie de prog !

Après il me reste les questions pratiques,
- les tableaux dont tu parles, ce sont des tableaux pour lesquels la i-ème ligne et la j-ème colonne donne les valeurs RVB du pixel indexé par (i,j) dans l'image considérée, non ? Mais ces tableaux sont-ils créés directement grâce à Dev-C++ ?

- Après avoir déterminé si un pixel (i,j) était de la "bonne" couleur, que dois-je faire ? Créer un point de coordonnées (i,j) dans une image de même dimension que celle de la vidéo dans laquelle j'ajouterai tous les points correspondants aux capteurs sur la même image analysée ? Si oui, comment (quels opérateurs,codes rentrer pour faire cela ?) ?

- Est-ce que je suis obligé de coder en C ? Parce que je veux bien croire que ce langage soit plus simple que Maple mais,étant donné que j'ai déjà quelques bases sur Maple (du point de vue algorithmique), ce ne serait pas plus simple dans mon cas de coder sur Maple au lieu de devoir tout apprendre sur le C ?

Encore merci pour tes réponses et leurs futures congénères (aux réponses ).

[inviteabd566ec]

Bonjour,

oui pour la première partie du programme c'est exactement ça (juste, j'aime pas trop le terme "compiler les images" parce que comme je l'ai déjà indiqué "compiler" a un sens bien précis en informatique ).

- les tableaux dont tu parles, ce sont des tableaux pour lesquels la i-ème ligne et la j-ème colonne donne les valeurs RVB du pixel indexé par (i,j) dans l'image considérée, non ? Mais ces tableaux sont-ils créés directement grâce à Dev-C++ ?

C'est toi-même qui va créer tes tableaux, selon la syntaxe du C. Je ne sais pas trop ce que tu veux dir par 'créés directement grâce à DevC++). Après pour le tableau il y a plusieurs méthodes : trois tableaux contenant chacun 1 couleur ; un tableau à 3 dimensions du type tablo[lig][col][couleur] ; ou même un simple tableau d'entier, avec la valeur val de chaque entier telle que val=256*256*rouge+256*vert+ble u (je cite celui-là car c'est en fait directement ce que te donnera ton fichier AVI). Dans tous les cas, les 3 méthodes se valent au niveau du traitement (j'ai une préférence pour la dernière, la seconde est plus élégante mais les tableaux à 3D c'est pas toujours très simple, la première utilise plus de mémoire, mais est plus immédiate à comprendre).

- Après avoir déterminé si un pixel (i,j) était de la "bonne" couleur, que dois-je faire ? Créer un point de coordonnées (i,j) dans une image de même dimension que celle de la vidéo dans laquelle j'ajouterai tous les points correspondants aux capteurs sur la même image analysée ? Si oui, comment (quels opérateurs,codes rentrer pour faire cela ?) ?

Ca c'est la partie où il va falloir réflechir. En gros en faisant comme tu dis, tu te retrouve (schématiquement) avec une image noir et des patés représentant les capteurs. Il faudra ensuite trouver pour chaque capteur le centre du paté (d'abord isoler chaque paté, et ensuite un petit calcul de barycentre par exemple).

- Est-ce que je suis obligé de coder en C ? Parce que je veux bien croire que ce langage soit plus simple que Maple mais,étant donné que j'ai déjà quelques bases sur Maple (du point de vue algorithmique), ce ne serait pas plus simple dans mon cas de coder sur Maple au lieu de devoir tout apprendre sur le C ?

Ca après c'est ton choix. Cependant, il faut être SUR que tu peux lire des fichiers binaires avec Maple. Après peu importe sur quoi tu programme. Seul bémol, ton programme sera plus lent sous Maple.
Note tout de même que tes bases en algorithmique te serviront en C : l'algorithmique est indépendante du langage. Ce qui change c'est uniquement la syntaxe. Ainsi, que j'écrive en Maple (pardon, mon Maple est très lointain) :

factorielle:=proc (n)
if (n>0 and abs(n)=n) then
   res:=1 ; 
   for i from 1 to n do 
      res:=res*i ; 
   od;
res
fi ;

ou en C :

int factorielle (int n)
{
int res ; 
int i ; 

if (n>0 && fabs(n)==n)
   {
   res=1 ; 
   for (i=1 ; i<n ; i++)
       {
       res=res*i ; 
       }
   }
return res ; 
}

c'est exactement la même structure algorithmique, et ça fait la même chose (aux erreurs de programmation près). Cependant, il y a aussi une vie après la prépa, et je crois que personne n'utilise Maple en tant que langage de programmation. C'est un langage de calcul formel ! Et pis Maple c'est pas gratuit non plus ... Bon faut que j'arrête d'essayer de vendre à tout prix le C ! Comme je l'ai dit, pour programmer en Maple il faut juste que tu vérifie avant que tu arrives de lire un fichier octet par octet dans Maple !

[inviteabd566ec]

Pour voir un peu mieux à quoi ça ressemble, tu peux consulter :
http://perso.ens-lyon.fr/nicolas.tab...enonce_td2.pdf => Gnéralités sur la programmation.
http://perso.ens-lyon.fr/nicolas.tab...enonce_td3.pdf => Syntaxe du C.

[invitea4a5c45a]

Je ne sais pas trop ce que tu veux dir par 'créés directement grâce à DevC++)

Ben comment tu crées les 3 tableaux R,V et B à partir d'une image ?
Il faut bien décomposer (en gros) décomposer l'image pixel par pixel et créer 3 tableaux dans lesquels figureront les valeurs RVB de chaque pixel, mais quels commandes permettent de faire cela ?

Ca c'est la partie où il va falloir réflechir. En gros en faisant comme tu dis, tu te retrouve (schématiquement) avec une image noir et des patés représentant les capteurs. Il faudra ensuite trouver pour chaque capteur le centre du paté (d'abord isoler chaque paté, et ensuite un petit calcul de barycentre par exemple).

Quand j'aurai vérifié si le pixel analysé correspond bien à un capteur (avec les boucles if par exemple), qu'est-ce que je dois faire ? Je saurai que le pixel de coordonnées (i,j) sur l'image appartient bien à un capteur. Faut-il alors (par exemple) que je crée une image blanche de même dimension que celle de l'image de la vidéo, puis que j'y introduise un pixel noir de coordonnées (i,j) ? Ainsi j'aurai en gros la vidéo mais sur lesquel on ne vois QUE les capteurs (que des bouillis noires qui bougent quoi (après vient le calcul du centre)) ?


Sinon je pense que je vais écouter tes conseils et m'essayer au codage en C .

Merci

[inviteabd566ec]

Ben comment tu crées les 3 tableaux R,V et B à partir d'une image ?
Il faut bien décomposer (en gros) décomposer l'image pixel par pixel et créer 3 tableaux dans lesquels figureront les valeurs RVB de chaque pixel, mais quels commandes permettent de faire cela ?

Dans ton fichier vidéo, tu as en fait juste des octets qui se suivent les uns à la suite des autres par groupe de 3. Les 3 premiers octets correspondent donc au premier pixel en haut à gauche de la première image. La première image est ainsi parcourue d'abord en ligne puis en colonne. Donc tes LARGEUR*3 premiers pixels représentent la première ligne de la première image, et l'ensemble des LARGEUR*HAUTEUR*3 premiers octets représentent la première image. Donc pour récupérer la première image en C, ça te donne quelque chose comme :

#include <stdlib.h>
#include <stdio.h>

// Constantes globales
#define LARGEUR 800
#define HAUTEUR 600

int main() // Partie principale du programme
{
// Ouverture du fichier
FILE *fichier ;
fichier=fopen("Video.avi", "rb") ;

int rouge[LARGEUR][HAUTEUR], vert[LARGEUR][HAUTEUR], bleu[LARGEUR][HAUTEUR] ;
int i, j ;

for (i=0; i<HAUTEUR ; i++)
{
for (j=0 ; j<LARGEUR ; j++)
{
fread(&rouge[j][i], 1,1, fichier) ; // Lire 1 octet 1 fois dans fichier et le placer dans rouge[j][i]
fread(&vert[j][i], 1,1, fichier) ;
fread(&bleu[j][i], 1,1, fichier) ;
}
}
}

Quand j'aurai vérifié si le pixel analysé correspond bien à un capteur (avec les boucles if par exemple), qu'est-ce que je dois faire ? Je saurai que le pixel de coordonnées (i,j) sur l'image appartient bien à un capteur. Faut-il alors (par exemple) que je crée une image blanche de même dimension que celle de l'image de la vidéo, puis que j'y introduise un pixel noir de coordonnées (i,j) ? Ainsi j'aurai en gros la vidéo mais sur lesquel on ne vois QUE les capteurs (que des bouillis noires qui bougent quoi (après vient le calcul du centre)) ?

Oui, c'est l'idée

[invitea4a5c45a]

Salut, Je tiens à m'excuser d'avance pour le pavé que je vais te pondre (j'espère que tu auras le courage (et la patience) de le lire en entier ^^)
Pour l'instant je me concentre sur la première partie du programme (la détection des capteurs).

Est-ce que cette pseudo-structure du programme est-elle bonne :

Créer une image blanche de 800x600 (je suppose la vidéo en 800x600)
Boucle sur les images
Pour une image, créer 3 tableaux R,V et B à 600 lignes, 800 colonnes
Lire les octet un par un
Placer le 1er dans la 1ère ligne 1ère colonne du tableau R
Placer le 2ème dans la 1ère ligne 1ère colonne du tableau V
Placer le 3ème dans la 1ère ligne 1ère colonne du tableau B
Placer le 4ème dans la 1ère ligne 2ème colonne du tableau R
Placer le 5ème dans la 1ère ligne 2ème colonne du tableau V
etc...
POUR i allant de 1 à 600, FAIRE
POUR j allant de 1 à 800, FAIRE
SI la valeur -ligne i colonne j- du tableau R est 0 ET la valeur -ligne i colonne j- du tableau V est comprise entre 250 et 255 ET la valeur -ligne i colonne j- du tableau B est 0
ALORS mettre un pixel noir en (i,j) sur l'image blanche créée au début

Au final j'obtiens une image blanche avec des taches noires correspondant aux capteurs

Je calcule pour chaque tache le centre du capteur (je ne sais pas encore comment procéder pour ça)



Voilà si déjà la structure est juste, pourrais-tu me donner un lien avec les différentes commandes de Dev-C++ (comment ouvrir une image; l'analyser octet par octet en regardant à chaque fois les valeurs R,V & B; comment créer un image blanche et y ajouter les pixels noirs au fur et à mesure;etc...) stp ?

Aussi, j'ai téléchargé,installé puis lancer Dev-C++, mais que dois-je faire pour commencer à écrire le programme ? Fichier->nouveau fichier source ? ou Fichier->nouveau projet ? etc...










Après, j'ai lu le dossier que tu m'as donné.
Les calculs sont assez complexes et il y a encore quelques points que je ne comprends pas .
Si je résume ce que j'ai compris, voilà globalement ce que ça donne :





Les donnés connues sont : a (qui dépend de la caméra)
alpha,bêta (qui caractérisent l'orientation d'une caméra)
les vecteurs oC1 et oC2 .

Soit un point A dans l'espace réel ,on note o1 et o2 les origines de l'image sur les caméras 1 et 2,
A partir de l'image d'une caméra, j'obtiens les angles thêta et phi,à partir desquels j'obtiens le point Fi (où i=1 ou2).
Je peux alors tracer les droites (C1 F1) et (C2 F2) dans l'espace. Ces droites ne se coupent probablement pas (du faite de l'imprécision des calculs).
Je calcule donc les 2 points M1 et M2 appartenant respectivement à (C1 F1) et (C2 F2), tels que M1M2 soit le plus petit élément de l'ensemble {MN,M appartenant à (C1 F1),N appartenant à (C2 F2)}, autrement dit, M1M2 est la distance entre les 2 droites.
Je prends le milieu du segment [M1M2].
Les coordonnées de ce point me donne celles du point A dans l'espace virtuel à créer.









Si jusque là j'ai bien compris, j'aurai déjà quelques questions :

1) Est ce que ça faciliterait les calculs si je plaçais les 2 caméras à la même hauteur et fixant dans la même direction (autrement dit je les colle côtes-à-côtes ) ?

2)Dans le dossier, je n'ai pas compris pourquoi l'origine devait être visible par les caméras ...

3)J'ai pensé à un moyen plus simple mais sûrement moins précis pour obtenir les coordonnées du point à mettre dans l'espace virtuel, dis-moi si ça tiens la route stp :

Je me restreins à un seul capteur pour cet exemple.
Je place les 2 caméras comme précisé en 2).
J'effectue la première partie du programme, ce que me donne des images blanches avec un unique point noir.
Si j'ai bien réglé le début des 2 vidéos (vu qu'il y a 2 caméras), la n-ème image de chaque vidéo correspond au même moment, filmé sous un angle différent (on devrait juste avoir un décalage horizontal).
A chaque fois, je prends la n-ième image de la première et de la seconde vidéo, je trace le segment reliant les 2 points noirs après avoir superposé les images.
Je prends le milieu de ce segment, ce que me donne les coordonnés du point dans un plan en 2D.
Pour la 3ème coordonnée, je l'obtiens en mesurant la distance horizontale entre les 2 points noirs, et en multipliant cette dernière par un facteur k (à déterminer). J'obtiens bien une 3ème coordonnée qui variera selon les capteurs, car l'écart horizontal observé et d'autant plus important que l'objet est proche.
J'obtiens alors pour un instant donné la position du capteur dans l'espace.







Voilà merci beaucoup d'avoir pris le temps de lire mon roman .
Je sais que tu n'as pas que ça à faire d'aider un MP errant et je te remercie du temps que tu m'accordes .

[inviteabd566ec]

Salut,

bo on a vu pire comme pavé . Bon, je vais essayer de répondre dans l'ordre.

Pour l'instant je me concentre sur la première partie du programme (la détection des capteurs).

C'est ce qu'il faut ! Ta structure de programme et la bonne. Il y a juste le "etc." qui est en fait simplement une boucle sur 800*600*3 octets (puisque c'est le nombre d'octet que représente une image dans ton fichier vidéo). Pour les commandes en C qui correspondent, voilà ce que ça donne :
- Ouverture d'un fichier : il faut d'abord déclarer la variable fichier (c'est à cette variable que tu te réfèreras ensuite dans le code pour lire le fichier), avec une ligne :

FILE *fichier;

et ensuite l'ouvrir :

"fichier=fopen("Nomdufichier.avi", "rb")

, le "rb" signifiant que tu veux lire (Read) octet par octet (Binary).
- Analyser octet par octet : pour extraire un seul octet du fichier, la commande c'est

fread(&octet, 1, 1, fichier)

où fichier est la variable ouverte précédemment, et octet est une variable temporaire qui contiendra la valeur de l'octet lu (il faut donc la déclarer précédemment en utilisant quelque chose genre

int octet ;

.
- Créer un image blanche et y ajouter les pixels noirs au fur et à mesure : tu commence par déclarer un tableau de 800*600 cases

int tableau[800][600] ;

, puis tu fais une boucle sur les lignes et une sur les colonnes pour l'initialiser à 255 (blanc) (en condensé ça donne:

int i, j ; for (i=0;i<800;i++) {for j=0;j<600;j++) { tableau[i][j]=255; } }

). Ensuite tu peux accéder à chaque case du tableau et en changer directement la valeur.

Pour utiliser Dev-C++, tu commences par Fichier-> Nouveau fichier source. Tu as une page qui s'ouvre. Tu tapes ton code. Quand tu es près à tester ton programme, tu cliques sur build->compile and run (ou quelque chose comme ça). Le programme devrait se créer et se lancer tout seul.

Pour tester, je te donne la source basique suivant. Je l'ai testé, quand tu le lance il doit t'écrire "Bonjour le monde" dans une console (c'est à dire dans un écran noir type MS-DOS). Je te conseille d'écrire directement ton programme à partir de cette source, parce qu'il faut indiquer les #include et main et tout ça et ça tu peux pas l'inventer (note que tout ce qui est après un double slash ou entre /*blabla*/ sont des commentaires). Pour tester, tu as juste à copier coller dans un nouveau fichier source, enrigistre le fichier et ensuite "compile&run".

#include <stdlib.h>
#include <stdio.h>

int main ()
{

  // Ecris à la place de la commande suivante ton code
  printf("Bonjour le monde\n") ; 

}

Est ce que ça faciliterait les calculs si je plaçais les 2 caméras à la même hauteur et fixant dans la même direction (autrement dit je les colle côtes-à-côtes ) ?

Ca clairement ! L'idéal pour avoir la meilleurs précision et les calculs les plus simple étant de les placer à 90° et de les pointer dans la même direction.

Dans le dossier, je n'ai pas compris pourquoi l'origine devait être visible par les caméras

Ce n'est pas du tout indispensable. Par contre comme c'est déjà chaud de connaître les positions des caméras et leur orientation, sans voir l'origine ça devient vraiment galère je trouve ! Et puis en général ce n'est pas une condition vraiment contraignant : les 2 caméras filmant plus ou moins la même chose, on peut généralement trouver un point que les 2 voient où placer l'origine.

Pour ta proposition de placer les 2 caméras côte à côte, ça doit effectivement fonctionner (je pense un peu moins précis mais faudrait vérifier). Comme je le met dans le doc, j'ai établi des formules générales (normallement), mais les cas particuliers sont souvent beaucoup plus simple (qui ferait cette expérience en plaçant les caméra vraiment n'importe comment ??? ).

[invitea4a5c45a]

Lut,
Encore merci pour ta réponse rapide et complète (comme toutes les autres d'ailleurs) tu es vraiment une personne de confiance !

Sinon j'ai de faire le code exemple que tu m'as donné mais quand je compile et exécute, la fenêtre type MS-DOS dans laquelle je suis censé voir le message s'ouvre et se referme immédiatement ! Je ne l'a vois même pas pendant une seconde !

Pour le "système" de calcul des coordonnées 3D à utiliser je vais tenter la méthode que je t'ai exposée, puis si j'y arrive (ou si elle se révèle inefficace) je tenterai celle de ton dossier (bien plus précise au passage) .

[inviteabd566ec]

Ha oui désolé j'avais oublié ce détail de la fenêtre qui se ferme d'un coup ! Tu peux rajouter la commande :

pause ;

après le printf pour pas qu'elle se ferme. Sinon si tu arrives à compiler c'est parfait, il ne te reste plus qu'à programmer .

(bien plus précise au passage)

Plus précise je suis pas sûr, comme il doit y avoir un taux très élevé de fautes de calcul ...

[inviteabd566ec]

Pardon, la bonne commande c'est :

system("pause") ;

[invitea4a5c45a]

Salut,
j'aimerais commencer à écrire le programme ce week-end mais il y a encore quelques précisions dont j'ai besoin:

1)après avoir fait "fichier=fopen("Nomdufichier.a vi", "rb") et int rouge[LARGEUR][HAUTEUR]; int bleu[LARGEUR][HAUTEUR]; int vert[LARGEUR][HAUTEUR]; je dois faire une boucle sur i puis sur j et fread(&rouge[i][j], 1, 1, fichier);fread(&bleu[i][j], 1, 1, fichier);fread(&vert[i][j], 1, 1, fichier) mais que désigne 1,1 ? Est ce que ça veut dire qu'il faut lire octet par octet ?Où un des 1 désigne "octet par octet" et l'autre 1 dit de lire le 1er octet (ça veut dire que pour rouge par exemple je devrait mettre quelque chose du genre fread(&rouge[i][j], 1, k+3, fichier) pour lire le 1er puis le 4ème octet etc...
Si oui,comment différencier les valeurs de rouge[i][j],bleu[i][j] et vert[i][j] ? Parce que la seule différence dans fread est que le nom de la variable est différent. Ca veut dire qu'il va me mettre les même valeurs pour rouge,bleu et vert.

2)Les 3 premiers octets correspondent aux valeurs R,V et B du premier pixel de la première image ?
Si oui, dans quel ordre se lisent les valeurs (1er octer=valeur en rouge,2ème=en vert,3ème=en bleu).

3)J'ai installé ImageJ mais je n'arrive pas à ouvrir de fichier .avi !Je fais File->Open... ou File->Import...->Avi... A chaque fois il me met un message du genre An error occurred reading the file. Unsupported compression: 31535046 'FPS1' ou An error occurred reading the file. Unsupported compression: 31535046 'XVID' .
Quel est le problème ?
Dès que j'aurai réussi à ouvrir une video, je dois faire File->Save As...->Raw Data ?

4)"fichier=fopen("Nomdufichier.a vi", "rb") ça m'ouvre la vidéo en format brut mais il nefaut pas spécifier son emplacement ? Du genre C:\Program Files\Video.avi ?

[inviteabd566ec]

Bonjour,

1) Non, c'est bien 1,1 partout ! en fait, cela signifie que fread va lire 1 octet (le 2e 1) par groupe de 1 octet (le premier 1). (1,100 voudrait dire 100 octets par groupe de 1 octet ; et 2, 50 voudrait bien sûr dire lire 50 groupe de 2 octet (soit 100 octets). Je rentre pas dans les détails mais il y a de bonne raisons que la fonction soit faite comme ça). De plus, fread avance dans le fichier à mesure qu'il lit. La 2e fois que la fonction fread(...,1,1,...) sera appelée, elle lira donc le 2e octet, et ainsi de suite. En conséquence, en appelant à la suite

fread(&rouge[i][j], 1, 1, fichier); 
fread(&vert[i][j], 1, 1, fichier) ; 
fread(&bleu[i][j], 1, 1, fichier) ;

tu lis bien 3 octets différents. Tes 3 variables ne contiendront donc pas les mêmes valeurs.

2) Il me semble que c'est dans l'ordre rouge - vert - bleu, même si j'en suis pas sûr à 100%. De toute façon ça change pas grand chose pour toi, au pire tu auras juste à renommer tes variables si tu te rends compte d'un problème de couleur.

3) Ainsi qu'il est indiqué, le problème est Unsupported compression . Essaye d'ouvrir ta vidéo avec VirtualDub (gratuit of course), je pense qu'il devrait y arriver. Ensuite tu pourra l'enregistrer comme un fichier AVI non compressé, que ImageJ doit pouvoir lire (ou même comme une séquence d'image JPEG, et là c'est sûr que imageJ peut le lire, aevc import-ImageSéquence). Sinon, VirtualDub peu peut-être directement te créer du non compressé RAW, il faut regarder.

Dès que j'aurai réussi à ouvrir une video, je dois faire File->Save As...->Raw Data ?

Oui !

4) Pour éviter les problèmes qu'on comprends pas d'où ils viennent, je te conseille de tester ton programme en mettant la vidéo dans le dossier où est ton programme (càd où tu as enregistré ton code source en fait). Sinon tu dois aussi pouvoir mettre le chemin mais il faut plutôt utiliser la notation MS-DOS (càd des antislash (double antislash même pour que le C comprenne) et max 8 caractères par nom de dossier ...). Autant dire qu'il est plus simple de mettre directement le fichier dans le bon répertoire !

Une commande qui peut être utile pour être sûr que le fichier est bien ouvert :

fichier=fopen("Nomdufichier.a vi", "rb") ; 
printf("!%d!", fichier) ; 
/* Affiche quelque chose de non nul si le fichier est bien ouvert. La 
commande printf peut être très utile pour voir la valeur de variables 
au cours de l'éxécution. Tu as juste à remplacer "fichier" par la 
variable (entière ! ) dont tu veux connaître la valeur). */

[invitea4a5c45a]

Bon je viens d'écrire une partie du programme et pour l'instant, au final j'ai une sorte de "tableau" (en fait des variable tableau indexée par un couple (i,j) ( où i compris entre 0 et 800 et j entre 0 et 600 ) où, pour tout i compris entre 0 et 800 et tout j entre 0 et 600, tableau[i][j] vaut 255 s'il n'y a pas de capteur au niveau du pixel de "coordonnées" (i,j) sur l'image, et 0 s'il il y a un capteur.

*Maintenant, comment fait-on pour créer une image de 800x600 dont les valeurs R,V et B en (i,j) seraient égales à celle de tableau[i][j] ?


*Sinon, je ne dois pas marquer .avi dans fichier=fopen("Nomdufichier.av i", "rb") vu que je lis un fichier RAW (et donc sans extension) non ?

*Comment faire une boucle sur les différentes images de la video ?
Parce que cette dernière n'est pas concrètement divisée en plusieurs images... C'est juste une suite d'octets non ?
Le bout de programme que j'ai écrit (avec rouge[i][j], tableau[i][j] , etc...) il faut que je l'applique tous les 800x600x3 octets ?

[inviteabd566ec]

Maintenant, comment fait-on pour créer une image de 800x600 dont les valeurs R,V et B en (i,j) seraient égales à celle de tableau[i][j] ?

Heu ... Je vois pas trop ce que tu veux faire : de toute façon ce tableau tu vas en avoir besoin pour la suite du programme, donc t'as pas vraiment besoin d'en faire une vraie image. Sinon, si tu veux vraiment, tu peux toujours réécrire une image en format brute :

FILE *output ;
output=fopen("Image.raw", "wb") ; 

POUR CHAQUE PIXEL :
{
fwrite (&red[i][j], 1, 1, output) ; 
fwrite (&greeb[i][j], 1, 1, output) ; 
fwrite (&blue[i][j], 1, 1, output) ; 
}
fclose (output) ;

Ah j'ai peut-être pas vraiment compris ce que tu voulais faire à la réflexion ...

Sinon, je ne dois pas marquer .avi dans fichier=fopen("Nomdufichier.av i", "rb") vu que je lis un fichier RAW (et donc sans extension) non ?

Ce que tu dois marquer c'est le nom du fichier avec son extension s'il en a une. Après à toi de voir comment tu l'as nommé.

Comment faire une boucle sur les différentes images de la video ?

Ba tu encastre ton code qui lit une image dans une boucle. Comme fread avance dans le fichier, après avoir lu toute une image tu seras au début de l'image suivante et tu pourras continuer à lire. Par contre, il faudra bien sûr que tu traites l'image en cours avant de passer à la suivante, puisque tes tableaux rouge, vert, bleu seront perdus (enfin, réécris).

[invitea4a5c45a]

Heu ... Je vois pas trop ce que tu veux faire : de toute façon ce tableau tu vas en avoir besoin pour la suite du programme, donc t'as pas vraiment besoin d'en faire une vraie image.

Ben en fait pour l'instant ce que j'obtiens c'est juste des valeurs tableau(i,j) ( où i entre 0 et 800 et j entre 0 et 600) et je voulais créer à partir de ça une image blanche en 800x600 avec des taches noires qui représenteraient les capteurs.
Mais tout bien réfléchis cette phase est inutile...Parce que je devrais plutôt calculer le centre de chaque capteur maintenant ...

Donc en fait,ce que je devrais faire après avoir obtenu les valeurs tableau(i,j), c'est calculer les centres des capteurs dont je mettrais les valeurs (i,j) (les coordonnées quoi) dans une variable du type capteur[k][l] où k désignerait le numéro de l'image et l celui du capteur.
Ensuite je fais pareil pour la 2ème vidéo (qui filme la même scène avec un décalage spatial horizontal ).
Puis pour chaque image et chaque capteur, j'ai donc 2 positions (celle sur la 1ère et celle sur la 2ème vidéo). Je calcule le centre du segment reliant ces 2 points, ce qui me donne les coordonnées x,y du capteur dans UNE image, et pour la coordonnée en z, je fais par exemple la différence des coord en x multipliée par un facteur.

J'ai bon ?

[inviteabd566ec]

Bonjour,

oui, c'est bon partout !
Je rajoute juste des petites précisions : ton tableau capteur est en fait à trois dimension : capteur[numero_image][numéro_capteur][axe de coordonnée x ou y] (voir même à 4 si tu ne veux qu'un tableau : capteur[numero_video][numero_image][numéro_capteur][axe de coordonnée x ou y]). Ce n'est pas grave mais il faut en être conscient.
Note qu'il va aussi falloir que tu numérote comme il faut tes capteur pour que un numero correspondent toujours au même capteur au cours du temps. Ce n'est pas si simple que ça à faire, à toi de voir comment tu vas coder ça !

[invitea4a5c45a]

Après avoir obtenu les valeurs tableau[i][j], si je rentre :
FILE *output ;
output=fopen("Image.raw", "wb") ;

int m,n ;
for (m=0;m<LARGEUR;m++)
{ for (n=0;n<HAUTEUR;n++)
{
fwrite (&tableau[m][n], 1, 1, output) ;
fwrite (&tableau[m][n], 1, 1, output) ;
fwrite (&tableau[m][n], 1, 1, output) ;
}
fclose (output) ;,
ça devrait me donner UNE image (une seule parce que je n'ai pas encore fait de boucle sur les images,donc seul les LARGEURxHAUTEURx3 premiers octets ont été lus) de la même taille que la vidéo,au format raw, blanche avec en noir les capteurs tels qu'ils le sont sur la premier image de la vidéo non ?
Si oui, comment le vérifier ? Le fichier est en raw donc je dois l'ouvrir avec ImageJ et le sauvegarder en jpeg ?

[inviteabd566ec]

Oui, il faut que tu l'ouvres dans imageJ. Par contre tu peux peut-être juste écrire une fois tableau[i][j] pour chaque pixel, ça te donnera une image en niveau de gris (il suffit de régler 8 bit après quant tu importes dans ImageJ).

[invitea4a5c45a]

J'ai écrit une petite partie du programme et l'ai testé sur une image de 160x120 (celle-ci ).
Le résultat que j'aurai dû avoir, c'est une image blanche en 160x120 avec un petit carré noir vers le milieu ...
Mais, après avoir obtenu le raw obtenu et l'avoir ouvert avec ImageJ (au passage j'ai ouvert en 8-bit, et réglé en 160x120 ) tout ce que j'obtiens c'est une image en 160x120 complètement noire,avec 2-3 "lignes" et demi de blanche au dessus ...
Je me permets donc de poser quelques questions pour savoir si il y a quelque chose que je n'ai pas compris :

Quand je convertis une image ou une vidéo en raw, ce que j'obtiens, c'est une sorte de "succession d'octets", qui 3 par 3 définissent les valeurs R,V et B d'un pixel . Ensuite, si par exemple, après avoir obtenu les valeurs rouge[i][j], vert[i][j] et bleu[i][j] pour (i,j)=(1,1), et si je met FILE *output ;
output=fopen("Image.raw", "wb") ;
{
fwrite (&tableau[i][j], 1, 1, output) ;
fwrite (&tableau[i][j], 1, 1, output) ;
fwrite (&tableau[i][j], 1, 1, output) ;
}
fclose (output) ;, je devrais obtenir un premier pixel soit complètement noir, soit complètement blanc non ?

[inviteabd566ec]

Bonjour,

bon, ça marche pas du premer coup, mais en programmation c'est plutôt le contraire qui est exceptionnel !
Pour ce qui est de la conversion d'une image en raw, je pense qu'effectivement tu obtiens une image avec tous les pixels à la suite, et 3 octets pour chaque pixel.
Par contre pour ton bout de code, la couleur de ton pixel dépendra des valeurs de tableau[i][j] bien sûr, donc s'il contient seulement 255 ou 0 effectivement tu dois obtenir un pixel soit noir soit blanc. Par contre, si jamais tu écris 3 fois le contenue de chaque case du tableau (tableau[i][j]), il faut bien sûr que tu ne mettes pas 8bit dans imageJ (puisque chaque pixel est dans ce cas codé en 24 bits). Et puis là comme c'est codé t'as qu'un seul pixel, mais c'est peut-être volontaire ...

Un petit conseil pour éviter de te prendre la tête avec les conversion et être sûr qu'elles se font comme tu le veux : tu télécharge un éditeur hexadécimal quelconque, tu ouvre ton fichier. Ca affichera la suite d'octet du fichier, et tu verras tout de suite comment est le codage et si ton fichier résultat ressemble à quelque chose de correcte.
Tu peux aussi afficher dans la console MS-DOS les coordonnées auxquelles ton programme détecte les pixels à détecter (cf qq post précédent). Ca te permet de savoir déjà si tes IF marchent.

[invitea4a5c45a]

Par contre pour ton bout de code, la couleur de ton pixel dépendra des valeurs de tableau[i][j] bien sûr, donc s'il contient seulement 255 ou 0 effectivement tu dois obtenir un pixel soit noir soit blanc.

Oui oui c'est bien ça .

Par contre, si jamais tu écris 3 fois le contenue de chaque case du tableau (tableau[i][j]), il faut bien sûr que tu ne mettes pas 8bit dans imageJ (puisque chaque pixel est dans ce cas codé en 24 bits)

Ah ça vient peut-être de là ^^ .
Je m'étais posé la question et j'avais essayé d'ouvrir en "1-bit Bitmap" avec ImageJ mais il m'affiche une fenêtre Log où il marque "java.io.EOFException" ...

Et puis là comme c'est codé t'as qu'un seul pixel, mais c'est peut-être volontaire ...

Oui après je fais une boucle sur les pixels.


Sinon je pourrais te montrer le bout de prog que j'ai écrit ? Je voudrais juste que tu le lises et que tu me dises seulement si ce qu'il fait est bien ce que je cherche à faire (à ce stade, c'est juste recréer la première image en blanc et tâches noires), après ça peut juste être dû à une erreur de syntaxe,auquel cas j'essaierais de la trouver ^^ ...

[inviteabd566ec]

1bit bitmap ça veut dire que chaque pixel est codé sur un seul bit, et ne peut donc valloir que 2 couleurs. Donc c'est surement pas ce dont tu as besoin.

Pour le code, tu peux me l'envoyer sans problème. Je te laisse mon adresse mail, se sera peut-être plus simple que sur le forum :
francois-guill.guillard2 arobase laposte point net.