Discussion :

[funkyKong]

Merci pour vos réponses

mais si je comprend bien en n'utilisant pas les string mais que des char je vais devoir lire octet par octet le fichier. Et comme je l'ai déja fait au tout début ca va me prendre 7h

Si je ne lis pas octet par octet et tout d'un coup, ranger ses 1000000 octet dans un char ce n'est pas trés pratique pour pouvoir faire des traitements aprés.

Le problème c'est que je dois pouvoir lire un octet en hexa (que je lise en char ou en string ne changera pas qu'il faudra que je fasse la conversion ascii hexa) et ensuite l'inverser (X0X1X2X3 en X2X3X0X1). Ce n'ai qu' aprés que je dois calculer sa valeur décimal.


Pour le format des pixel, cela dépend du type d'image. Je dois traiter tout type d'images.
Avant la partie data à proprement parlé, il y a tous les champs informations en hexa comme le nombre de bit par pixel (qui varie entre 1 et 16) la taille l'image, le dataTypeId, etc....

[icer]

4 floats.

mais si je comprend bien en n'utilisant pas les string mais que des char je vais devoir lire octet par octet le fichier. Et comme je l'ai déja fait au tout début ca va me prendre 7h

Non. Tu créer un buffer de char de la taille de ton fichier, ensuite tu charges ton fichier dedans en une seule fois, enfin tu fais tes traitements.

Code :

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

1
2
3
4
5
6
7
8
// chargement
char* buffer = malloc(TAILLE_DU_FICHIER);
ifstream f_in("ton_fichier_image.ser");
f_in.read(buffer, TAILLE_DU_FICHIER);
f_in.close();
 
// traitement
...

Le problème c'est que je dois pouvoir lire un octet en hexa (que je lise en char ou en string ne changera pas qu'il faudra que je fasse la conversion ascii hexa) et ensuite l'inverser (X0X1X2X3 en X2X3X0X1). Ce n'ai qu' aprés que je dois calculer sa valeur décimal.

Qu'est-ce que tu entend par "lire un octet en hexa"?
Peu importe la représentation de ton octet, tous ce que tu veux c'est pouvoir les changer de place.

Code :

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

1
2
3
4
5
6
7
8
9
10
char[4] in ; // tes 4 octets lues (depuis ton buffer)
char[4] out ; // les quatres octets aprés la conversion
... // initialisation char[4] in
 
// conversion
out[0] = in[2];
out[1] = in[3];
out[2] = in[0];
out[3] = in[1];
...

[funkyKong]

Merci beaucoup pour ta réponse

En fait je crois que suis obliger d'avoir les valeurs hexa. Cela pour deux raison:

1) Avant le le traitement, il y a environ 200 octets de champs informations.
C'est important de les lire dans la mesure où il me renseigne à quel octet commence la partie data, combien il y a de pixel dans l'image, quel est le data type de l'image, quel est la calibration de l'image.
Il faut donc que je compare la valeur d'un octet à la valeur d'un hexa.

Par exemple pour un octet n°xx
Si il es égale à $4849 alors le data type de l'image c'est du 2 byte par integer
Si il est égale à $4126 alors c'est du 16 byte complex.

Autre exemple un octet nous renseigne su la taille d'un champ d'information.




2) Il faut que je caclul les valeurs décimal de chaque octet du champ data afin de l'ecrire dans le fichier destination. Et ca je pense pas que ca soit possible avec les valeurs en ascii. Je pensais convertir les valeurs ascii en hexa, puis calculer la valeur décimal à partir de l'hexa.


Ah oui au fait pourquoi tu as pas fait un new au lieu du malloc

[icer]

Les images que tu traites ne sont pas des images points par points (formées de pixels), mais plutôt des images vectorielles, non ?

2) Il faut que je caclul les valeurs décimal de chaque octet du champ data afin de l'ecrire dans le fichier destination. Et ca je pense pas que ca soit possible avec les valeurs en ascii. Je pensais convertir les valeurs ascii en hexa, puis calculer la valeur décimal à partir de l'hexa.

Si j'ai bien compris, tu as des valeurs binaires dans un fichier et tu veux les transcrire en chaîne de caractéres dans un autre fichier...

J'ai vraiment du mal à saisir ton problème, est-ce que tu pourrais nous montrer un exemple de ce que tu as comme données et à quel résultat du veux arriver.

Comme :
entrée : 0xA0 (un octet en hexa)
sortie : "10" (chaine de caractéres)

Ah oui au fait pourquoi tu as pas fait un new au lieu du malloc

Désolé, j'ai mélangé avec le C. Mais le new serait plus approprié c++, en effet.

[funkyKong]

Je crois que les images que je traite sont bien des images formé de pixel (j'ai vraiment peu d'informations dessus)

En fait : -- cela concerne juste pour le champ data
je dois
-lire les octets data du fichiers .ser en hexa,
-remettre les octets dans le bon ordre (et cela tous les deux octets vu qu'un pixel fait 2 octets dans le cas où le data type c'est de l'integer 2)
- ensuite je peut calculer leur valeur réele (float)
- puis stoker dans le fichier de sortie dans le champs data les float (sachant qu'un pixel est sur deux octet)

Donc si je lis: "0a01" à la position i:
- d'abord je l'inverse => "010a"
-puis je calcul la valeur réele soit 26
- enfin j'ecris dans le champ data du fichier de sortie (.dm3) en float 26


Autre chose quand je lis les octets en héxa dans le fichier de départ, j'ai des caractère en trop du genre fffff1c , je dois donc traiter cela en les supprimant. Et si la valeur hexa est 0a alors étant donné que quand je lis en hexa ca m'affiche juste a, il faut que je rajoute un 0 devant.

[icer]

Je crois que les images que je traite sont bien des images formé de pixel (j'ai vraiment peu d'informations dessus)

Dans ce cas, ça va être trés trés trés trés difficile pour toi. Il n'y a pas de documentation sur ton format? Avec quel logiciel tu peux le lire? Peut-être qu'il existe un logiciel ou une librairie qui effectue déja le traitement que tu souhaite faire. Tu as fait des recherches à ce niveau?

Je ne comprend toujours pas pourquoi tu "lis en hexa".
Si tu as deux octet dans ton fichier d'origine.
1. Tu les lit dans un char buffer[2]

Code :

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

f_in.read(&buffer, 2);

2. Tu les inverses :

Code :

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

1
2
3
char tmp_char = buffer[0];
buffer[0] = buffer[1];
buffer[1] = tmp_char;

3. Tu récupére la valeur entiére des deux char en castant

Code :

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

int i = (int)(buffer);

4. Tu formate ton nombre en hexa : là je t'envois vers la documentation de fprintf, il y a des options de formatage pour gerer les 0 de tes hexa

[funkyKong]

Les images en .ser ne sont lisible avec aucun logiciel : le logiciel tia (emispec ) génère des fichiers en .emi et en même des .ser . Il lit les .emi mais les .ser sont pareil (pas dans le formats mais c'est une image identique - même taille). Il n'y a qu'une seul doc sur tout le web sur les .ser et aucune sur les .emi .

Je dois donc transformer les .ser en .dm3 (digital micrograph). Là aussi il y a qu'une seul doc sur le web


http://phyweb.physics.nus.edu.sg/~phybcb/info/index.html

Pour l'inverse je l'avais déja inverser. Pour le fprintf, je vais regarder ca mais j'aime pas trop utiliser une librairie c au lieu d'une c++

Le plus gros problème qui j'ai en fait c'est le temps de faire tous ces traitement dans le buffer. J'ai testé ca et ca prend une dizaine d'heure au lieu de 10s.

Aprés j'ai aussi ce fichus caractères spéciaux qui m'enpêche pour le moment de lire en une seul fois dans le buffer: il apparaissent aléatoirement et sans les traiter au cas par cas, quand je lis le fichiers, je vois pas comment je vais faire pour les traiter lorsque j'ai tout mis dans le buffer.

Mais en tous cas merci pour toute l'aide que tu m'a apportée

[funkyKong]

Cela ne marche pas

3. Tu récupére la valeur entiére des deux char en castant

Code :

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

int i = (int)(buffer);

Quand je fait ca:

Code :

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

1
2
3
4
5
6
 
char * buff = new char[2];
buff[0] = buffer[6];  //buff[0] = 41
buff[1] = buffer[7];  //buff[1] = 22
int i = (int)(buff);   
PlugIn::gResultOut  << i << endl;  // cela m'affiche 73551936

[icer]

c'est normale que ça ne marche pas... ou plutôt que ça ne te donne pas le résultat que tu attends.

Attention à cette ligne :

Code :

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

int i = (int)(buff);

buff est un pointeur !
ici, on demande de caster l'addresse stocker dans buff vers un int. Et non pas la valeur pointer par buff.

Voilà ce que l'on cherche :

Code :

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

int i = *((int*)buff);

d'abord on cast le pointeur buff vers un pointeur sur un int, ensuite on récupére la valeur pointée pour la stocker dans i.

Il y un autre problème: la taille d'un int est de 4 octets (sur ma machine en tout cas). Or notre buffer n'en fait que 2. Donc il y a un débordement.

Il faut que notre buffer soit de 4 octet aussi.

voici le code corigé :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
 
char* buff = new char[4];
 
 
buff[0] = buffer[6];  //buff[0] = 41
buff[1] = buffer[7];  //buff[1] = 22
buff[2] = 0x00;
buff[3] = 0x00;
 
 
int i = *((int*)buff);
cout  << i << endl;  // affiche 5673
...
 
delete buff;

remarque : Il n'est pas nécessaire d'allouer buff en dynamique.

[funkyKong]

exacte. C'était vraiment une coquille de bas niveau.

A propos pour la lecture du fichier et le traitement des pixels ca me prend maintenant que 15s (sans l'ecriture).
J'ai compris pourquoi ca mettait 150h: à chaque pas de la boucle je fait un cout, ce qui ralentissais le tout à mort. Sans cout ca prend 15s.

Merci

[icer]

Voilà un problème résolue !