OpenCV: Charger une séquence d'images "File00X.png"

Version imprimable

Bonjour, tout est dans le titre !!

Je souhaiterais charger une par une la séquence d'images intitulées "File001.png", "File002.png", ..... "File00X.png", puis effectuer sur chacune des calculs de comparaison avec une autre image fixe "banque_de_france.png".

Je sais charger une image, mais je ne sais pas comment charger une séquence d'images, alors bien sûr avec une boucle comme je l'ai ébauchée dans le code ci-dessous, mais comment dépatouiller le truc?? :calim2:
Code:

1 2 3 4 5 6 7 8 9 10 11 int mainStaticMatch() { IplImage *img1, *img2[3]; img1 = cvLoadImage("Banque_de_France1.jpg"); for (int i=0; i<3; i++) { img2[i] = cvLoadImage("file"+i+".jpg"); NE MARCHE PAS :( }
Votre aide de pro de l'informatique me serait fort utile !!;)

Tu pourrais déjà utiliser l'API C++ d'OpenCV :

Code:

1
2
3
4
5
6
7
8
9
cv::Mat bdf = imread("Banque_de_France1.jpg");
cv::Mat sequence[3];
 
for (int i=0; i<3; ++i)
{
std::stringstream ss;
ss << "file" << i << ".jpg";
sequence[i] = cv::imread(ss.str());
}

03/02/2012, 12h19
wilfryjules

merci pour votre aide gracieuse !! :ccool:

je vais voir tout ça !! j'allume mon neurone !

RE !!!! Malaheureusement ce programme compile, mais l'image ne s'affiche pas !!!
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 int mainStaticMatch() { IplImage *img1; Mat img2[3]; img1 = cvLoadImage("Banque_de_France1.jpg"); for (int k=0; k<3; k++) { stringstream ss; ss << "file" << k << ".jpg"; img2[k] = imread(ss.str()); } cvNamedWindow("1", CV_WINDOW_AUTOSIZE ); cvShowImage("1", &img2[0]); cvWaitKey(0); return 0; }
NB: Voici comment sont stockées mes images:

file-00001.jpg
file-00002.jpg
file-00003.jpg

L'emplacement est bon, car j'arrive à charger et à afficher img1 qui se trouve au même endroit !!!

IL ne peut donc y avoir que 2 erreurs possibles:
- soit votre code est déficient (peu probable étant donné votre talent!)
- soit le "nom à numéros " file-0000x n'est pas reconnu. Quel format de nom dois-je donner à mes images?

:?

merci !!

03/02/2012, 23h37
Ekleog

Le nom à numéro est mal reconnu. Tu as oublié un "-" dans ta façon de former le nom de fichier. ;)

En plus, tu n'inclus pas les 0.

Bref, les fichiers que tu essaies d'ouvrir actuellement sont file0.jpg, file1.jpg, et file2.jpg .
03/02/2012, 23h39
cob59

J'ai voulu éditer mon message pour prévenir que le stringstream allait contenir des noms de fichier du type "fileN.jpg" au lieu de "file000N.jpg", j'aurais peut-être dû.

Si c'est gênant, il suffit de formater un peu :

Code:

ss << "file-" << setfill('0') << setw(4) << i << ".jpg";

Pour plus de détails :
http://www.cplusplus.com/reference/i...ators/setfill/
http://www.cplusplus.com/reference/i...pulators/setw/

PS : Si le reste du programme est codé avec l'API C d'OpenCV (IplImage* au lieu de cv::Mat, typiquement) alors oublie ce que j'ai dit et n'utilise pas cv::Mat ni le reste de l'API C++ ; ce serait plus source de conflits qu'autre chose.

Merci pour toutes ces informations !
J'ai toujours une erreur malgré tout, la voici:

J'ai simplifier l'appellation des img2[]:
file1.jpg
file2.jpg
file3.jpg

Exception non gérée à 0x5093dfc3 dans TestOpenCV.exe*: 0xC0000005: Violation d'accès lors de la lecture de l'emplacement 0x0053857d.
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 #include <stdlib.h> #include "surflib.h" #include "kmeans.h" #include <ctime> #include <iostream> #include <iomanip> int mainStaticMatch() { IplImage img1; IplImage img2[3]; img1 = *cvLoadImage("Banque_de_France1.jpg"); for (int k=0; k<3; k++) { stringstream ss; ss << "file" << k << ".jpg"; //ss << "file-" << setfill('0') << setw(4) << k << ".jpg"; img2[k] = imread(ss.str()); } cvNamedWindow("1", CV_WINDOW_AUTOSIZE ); cvShowImage("1", &img2[0]); cvWaitKey(0); return 0; }
Votre aide me serait fort utile... :ccool:

Sinon avec ce code ci-dessous, j'obtiens une image mais elle est totalement bruitée ! Peut être que le stringstream ne fonctionne pas bien...

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
 
int mainStaticMatch()
{
  IplImage img1;
  //IplImage img2[3];
  IplImage img3; 
 
  //img1 = *cvLoadImage("Banque_de_France1.jpg");
 
 // for (int k=0; k<3; k++)
//  {
	stringstream ss;
	ss << "file" <<1<< ".jpg";
	//ss << "file-" << setfill('0') << setw(4) << k << ".jpg";
	img3 = imread(ss.str());
 
 // }
 // img3 = 	img2[0];
 
  cvNamedWindow("1", CV_WINDOW_AUTOSIZE );
  cvShowImage("1", &img3);
  cvWaitKey(0);
 
  return 0;
}

04/02/2012, 14h40
koala01
Salut,

Il serait peut etre bon que tu comprennes ce que Ekleog t'a fait faire, et pourquoi, car le stringstream n'a strictement rien à voir dans l'histoire :D

Il faut savoir que, lorsque tu travailles avec des valeur de type "fichier" ou ".jpg", ce sera, le plus souvent, considéré comme un const char * ou, pour être précis, comme un pointeur sur une valeur de type char.

Or, un pointeur n'est jamais qu'une valeur numérique "classique" dont la seule particularité est de représenter l'adresse mémoire à laquelle on va trouver une donnée du type indiqué.

Et donc, lorsque tu écrivais ton code sous la forme de
Code:

1 2 3 4 for (int i=0; i<3; i++) { img2[i] = cvLoadImage("file"+i+".jpg"); NE MARCHE PAS :( }
ce que tu faisais, c'est transmettre une valeur correspondant à l'adresse à laquelle se trouve le 'f' de "file" (par exemple 0x33355 ) + la valeur de i (par exemple 3) + l'adresse à laquelle se trouve le '.' de ".jpg" (par exemple 0x3335A), soit, pour suivre mes exemple, 0x666B2 qui sera considérée par la fonction cvLoadImage comme étant l'adresse à laquelle il devrait trouver la première lettre du nom du fichier qu'il doit charger.

Tu auras compris que cela ne correspond absolument pas à ce que tu veux faire en réalité :D

Non, ce que tu veux faire, c'est concaténer une chaine avec la représentation sous forme de chaine de caractères d'un valeur numérique et avec une deuxième chaine de caractères!!!

Le problème principal, c'est que, en informatique, le caractère '1' ne vaut pas 1 :aie: :

En effet, le char a cette particularité de représenter deux choses tout à fait différentes : d'une part, un "symbole (éventuellement) affichable", déterminé par sa position dans ce que l'on pourrait appeler une "table de conversion" et d'autre part une valeur numérique "classique" dont la valeur est, comme tout valeur numérique, limitée en fonction du nombre de bits qui permettent de la représenter.

Comme le type char est (généralement :D ) défini comme étant un groupe de 8 bits consécutifs, il y a donc (2^8-1 = ) 255 valeurs possibles, et donc 255 positions dans ce que j'ai appelé (par abus de langage il faut le savoir) la table de conversion de char en symbole affichable.

Et, d'après la table couremment utilisée (la table ASCII), la valeur associée au symbole du chiffre '1' est en réalité 49 (soit 0x31, en hexadécimal).

Il faut donc faire en sorte de convertir la valeur numérique que tu utilise comme compteur pour ta boucle en (suite de ) caractère(s) susceptible d'être utilisé(e) pour la concaténation avec une chaine de caractères.

Les classes *stringstream sont, justement, des classes dont le but est de permettre la conversion de "n'importe quoi" (par exemple des chaines ou des valeurs numériques) en chaine de caractères et / ou inversement.

Ainsi, quand cob écrit le code
Code:

1 2 3 4 5 6 for (int i=0; i<3; ++i) { std::stringstream ss; ss << "file" << i << ".jpg"; /*...*/ }
il dit
- on va avoir un compteur qui va compter de 0 à deux inclus (ca, c'est le for ( ... ) )
- pour chaque valeur du compteur, on va créer un flux de conversion nommé ss (ca, c'est le std::stringstream ss; )
- On va placer dans la "moulinette" stringstream une chaine ( "file" ), le compteur ( i ) et une autre chaine ( ".jpg" ) (ca, c'est le ss<<"file"<<i<<".jpg"
Comme le but de la classe stringstream est de faire des conversions, on sait que ss nous renverra (grâce à la fonction membre str() ) une chaine de caractère de type fileXXX.jpg (où XXX représente la valeur de 1 ).

Et c'est, justement, ce qu'il nous faut :D

Ce qui est fait de la chaine ainsi obtenue par la suite n'a strictement plus rien à voir avec la fameuse classe stringstream!!!! Elle a rempli son office exactement de la manière que l'on attendait d'elle, le reste va dépendre de la fonction qui va utiliser cette chaine de caractères pour aller charger le fichier correspondant ;)

Si donc les fichiers sont "bruités" comme tu sembles le dire, c'est, de toute évidence qu'il y a "un os" au niveau du chargement du fichier!!!

Je ne connais pas suffisamment OpenCV pour dire quoi que ce soit, mais j'envisage deux sources potentielles à ce problème:
- Soit tes fichiers ne sont pas réellement au format jpg, bien qu'ils en aient l'extension
- Soit le format de fichier n'est pas correctement pris en charge par OpenCV
En toute honnêteté, je dois dire que je pencherais plutôt pour la première cause, car le format jpg est un format libre et abondamment commenté et étudié, et, connaissant la réputation de OpenCV, je doute quand même sincèrement qu'elle ne soit pas capable de supporter correctement ce format de fichier ;)

Merci pour votre aide !!

Le problème ne vient pas de mes images, j'arrive à les charger dans la mesure où j'écris simplement *cvLoadImage("file1.jpg");

Mais cela ne marche plus si j'utilise stringstream:

- soit avec le code ascii de "1" = 49
- soit directement en écrivant "1"
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 int mainStaticMatch() { IplImage img3; stringstream ss; ss << "file" <<49<< ".jpg"; // ou ss << "file" <<"1"<< ".jpg"; // ou ss << "file1" << ".jpg"; // NE MARCHE PAS DANS TOUS LES CAS img3 = imread(ss.str()); cvNamedWindow("1", CV_WINDOW_AUTOSIZE ); cvShowImage("1", &img3); cvWaitKey(0); return 0; }
:roll: le problème viendrait donc de stringstream vous pensez?

04/02/2012, 15h28
koala01
Attention!!!

Sauf erreur de ma part, cvLoadImage demande sans doute un const char * (une chaine de caractère "C style", or, la fonction str() de la classe stringstream renvoie... une std::string(une chaine de caractères "C++").

si c'est le cas, tu peux récupérer une "chaine C style" au départ d'une std::string grâce à la fonction membre c_str() ;)

Le code deviendrait alors proche de
Code:

1 2 3 4 5 6 for(int i = 0; i< 3; ++i) { std::stringstream ss; ss << "file"<<i<<".jpg"; cvLoadImage(ss.str().c_str()); }
Pour les explications :
la classe stringstream dispose d'une fonction membre str() qui renvoie une std::string et présente la signature suivante: std::string const stringstream::str() constNous appelons donc la fonction membre c_str() de la classe std::string depuis la std::string que renvoie la fonction str() du stringstream.

c_str() est la fonction de std::string qui renvoie une chaine de caractères "C style" et qui présente, quand à elle, la signature suivante: const char* string::c_str() const;;)

Merci bien !!

En effet cela fonctionne ! Voici le code:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
 
 
 
int mainStaticMatch()
{
 
  IplImage *img3; // pointeur sur une IplImage 
 
  stringstream ss;
  ss << "file" << 1 << ".jpg";
  img3 = cvLoadImage(ss.str().c_str());     
 
  cvNamedWindow("1", CV_WINDOW_AUTOSIZE );
  cvShowImage("1", img3);
  cvWaitKey(0);
 
  return 0;
}

Merci encore ! :ccool:

Il y a, en réalité, une autre manière bien plus noble de charger une séquence d'images, la voici:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
 
 
 
 
#include <stdlib.h>
#include <stdio.h>
 
// N.B. To make this work correctly with MS Visual Studio 2003/05 
// do the following:
// * Open Project Menu -> <your project name> Properties
// * Open Configuration Properties -> Linker Tab -> Input 
// * In the "Additional Dependancies" box (where you also have the OpenCV dependancies)
//   add in the filename "setargv.obj" (with no quotes, after the OpenCV stuff that is  
//   already there)
//
// When you compile you may get a warning about there not being a debug library found
// or similar. Ignore this. Run program of the form "programename /path/to/files/*" and
// the file names in the specified directory should be correctly displayed by the following
// code. No change to the C/C++ code is required.
//
// Reference : http://msdn2.microsoft.com/en-us/library/8bch7bkk.aspx
 
// N.B. #2 This only works correctly with wildcards (i.e. /path/to/files/*jpg) when 
// there are no spaces in the file path. Use relative paths from the executable location
// to the required files.
 
 
 
 
int main(int argc, char *argv[])
{
 
   // create a list of images to study
   Mat img2[579];
 
  for(int i = 1; i < argc; i++)
    {
      printf("File %i : %s\n", i, argv[i]);
      img2[i] = imread(argv[i], CV_LOAD_IMAGE_COLOR);  
    }
}

Ce code reconnaît automatiquement les fichiers à (aux) emplacements donné(s) en entrée du programme par l'utilisateur.

Il est donc souhaitable de lancer l'application avec la console de l'ordinateur.

Citation:
Envoyé par wilfryjules
Il y a, en réalité, une autre manière bien plus noble de charger une séquence d'images, la voici:
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 #include <stdlib.h> #include <stdio.h> // N.B. To make this work correctly with MS Visual Studio 2003/05 // do the following: // * Open Project Menu -> <your project name> Properties // * Open Configuration Properties -> Linker Tab -> Input // * In the "Additional Dependancies" box (where you also have the OpenCV dependancies) // add in the filename "setargv.obj" (with no quotes, after the OpenCV stuff that is // already there) // // When you compile you may get a warning about there not being a debug library found // or similar. Ignore this. Run program of the form "programename /path/to/files/*" and // the file names in the specified directory should be correctly displayed by the following // code. No change to the C/C++ code is required. // // Reference : http://msdn2.microsoft.com/en-us/library/8bch7bkk.aspx // N.B. #2 This only works correctly with wildcards (i.e. /path/to/files/*jpg) when // there are no spaces in the file path. Use relative paths from the executable location // to the required files. int main(int argc, char *argv[]) { // create a list of images to study Mat img2[579]; for(int i = 1; i < argc; i++) { printf("File %i : %s\n", i, argv[i]); img2[i] = imread(argv[i], CV_LOAD_IMAGE_COLOR); } }
Ce code reconnaît automatiquement les fichiers à (aux) emplacements donné(s) en entrée du programme par l'utilisateur.

Il est donc souhaitable de lancer l'application avec la console de l'ordinateur.
Oulahhh... Bon dieu!!!

Il y aurait beaucoup à dire sur ce morceau de code :aie:

D'abord, c'est du pur code C, or, nous sommes dans la section C++...

Ensuite, ne t'en déplaise, cette manière de travailler présente un obstacle majeur :

L'utilisateur dispose d'une liste de noms bien définis et souhaites, justement générer les noms de fichiers de manière automatique, alors qu'il devrait se "palucher" le fait de les écrire tous à la main avec ta solution ;)

(en outre, ce n'est peut etre qu'un détail, mais: que se passe-t-il si l'utilisateur décide de faire charger plus de 579 images, et, dans l'autre sens, tu t'imagine l'utilisateur se palucher l'écriture à la main de 579 noms de fichier (avec leur chemin d'accès, là où seule une partie du nom change de manière clairement définie et reproductible :question: )

07/02/2012, 19h14
Ekleog

D'où le commentaire sur les wildcards ... :whistle:
09/02/2012, 14h02
jblecanard

Bof, la liste des fichiers peut être générée par un petit script dont c'est la tâche. Ca évite de trop se casser la tête en C++ pour faire ça et surtout ça permet de changer facilement le formatage du nom sans avoir à recompiler.