Problème de lecture de fichiers binaires

Version imprimable

Bonjour,

Dans mon programme, j'ouvre des fichiers binaires (qui sont des images). Certain fichiers ont les valeurs codées sur 1 octet d'autres sur 2 et enfin d'autres sur 4.

J'ai donc voulu écrire un Loader qui permet en renseignant le nombre d'octets sur lesquelles les valeurs sont codés de charger les données de l'image pour les mettre dans un vecteur de floats (car après je travaille avec des images flottantes.
C'est à ce moment que j'ai un problème :

Pour faire une fonction qui est générique, je bricole en déclarant la fonction template pour le nombres d'octets lus :

Code:

1
2
3
 
template<typename T>
static vector<float> *LoadFile(char const * fileName, T nbBytes)

Je fais ça car quand je lis le fichier je procède ainsi :

Code:

1
2
3
4
5
6
7
8
 
            while (i<vecSize) //vecSize est la taille du fichier binaire/nbBytes
            {
                T val;
                inFile.read(reinterpret_cast<char*>(&val), nbBytes);
                (*res)[i] = float(val);
                ++i;
            }

Je n'ai pas l'impression de bien programmer en faisant ça :( . D'autant que pour l'appel de fonction ça devient par exemple:

Code:

1
2
3
4
 
vector<float> *rawData = RawDataLoader::LoadFile(mask.c_str(),(float)4);
//ou
vector<float> *rawData = RawDataLoader::LoadFile(mask.c_str(),(unsigned char)1);

Je ne sais pas le faire correctement donc si vous avez des pistes svp ?

Pour le code complet de la fonction :

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
 
   template<typename T>
    static vector<float> *LoadFile(char const * fileName, T nbBytes)
    {
        ifstream inFile(fileName, ifstream::binary);
 
        if (inFile)
        {
            inFile.seekg(0, inFile.end);
            int length = inFile.tellg();
            inFile.seekg(0, inFile.beg);
            cout << "length is " << length << endl;
 
            size_t vecSize = length/nbBytes;
 
            vector<float> *res = new vector<float>(vecSize);
            unsigned int i = 0;
            while (i<vecSize)
            {
                T val;
                inFile.read(reinterpret_cast<char*>(&val), nbBytes);
                (*res)[i] = float(val);
                ++i;
            }
            inFile.close();
            return res;
        }
        else
        {
            cerr << "When openning " << fileName << " : no such file or directory" << endl;
            exit(1);
        }
    }

05/07/2013, 10h14
Médinoc

J'ai du mal à voir pourquoi le nombre d'octets à lire devrait être générique, plutôt que le type size_t.
05/07/2013, 10h25
-Gesicht-
Citation:

J'ai du mal à voir pourquoi le nombre d'octets à lire devrait être générique, plutôt que le type size_t.

J'avais un problème lors de la lecture :
Code:

1 2 3 4 T val; inFile.read(reinterpret_cast<char*>(&val), nbBytes); (*res)[i] = float(val);
Si je met le mauvais type à val, ça me donne des valeurs fausse. Je pensais mettre le bon type à val en le déterminant avec le type de nbBytes. En fait c'est comme si je veux passer en paramètre un type (et non pas une valeur). C'est pour ça que j'ai mis le nombre d'octec en T.
05/07/2013, 10h25
alyma

Oui voilà, moi aussi j'aurai mis un size_t.

Du coup, il serait peut être plus judicieux d'utiliser la fonction get() en indiquant la taille voulue (le size_t paramétrable).
A partir de là, tu récupères la chaîne avec 1, 2 ou 4 octets... et tu peux utiliser strtol pour la convertir en base 16.

On ne peut pas se baser sur la taille seule, car int et float tendent à faire tous les deux 32 octets.

Le plus simple pour des templates, c'est un truc de ce genre:
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 template< class T > void read(T* buf, size_t nbElems) { size_t nbBytes = nbElems*sizeof(T); inFile.read(reinterpret_cast<char*>(buf), nbBytes); } template< class T, size_t N > void read(T (&buf)[N])) { read(&buf[0], N); } //EDIT template< class T > void read(std::vector<T> &buf) { read(&buf[0], buf.size()); }
En typage statique, il est avantageux de passer la destination par pointeur ou référence plutôt que la retourner, car ça permet de déterminer le type à partir des paramètres.

Après, si tu veux que ton typage soit carrément dynamique, ça va être beaucoup plus dur.

05/07/2013, 13h31
Bousk
Bonjour,

- pourquoi allouer dynamiquement un vector ?
- pourquoi ne pas lire tout simplement le fichier en une fois ?
Code:

1 2 inFile.read(reinterpret_cast<char*>(&val), nbBytes); (*res)[i] = float(val);
Si c'est juste pour lire tout à la suite dans l'ordre et les mettre dans un vector, aucun intérêt à ne pas le faire vraiment en une fois
Code:

1 2 3 std::vector<float> vec; vec.resize(infile.gcount() /* / sizeof(float) ?*/); infile.read(&(vec[0]));
A la louche :aie:
05/07/2013, 14h35
-Gesicht-

Tout d'abord merci pour vos réponses :D

Citation:

- pourquoi allouer dynamiquement un vector ?

Parce que je manipule ensuite des images qui ont des vector<T> *data (pour les valeurs des voxels).

Citation:

- pourquoi ne pas lire tout simplement le fichier en une fois ?

Dans la solution que tu proposes, si les données sont codées sur 1 octet par exemple (ou sur un nombre différent d'octets que pour un float), lire tout le fichier pour l'écrire dans vec donne des valeurs fausses car il interprète les quatres premiers octets comme une seule valeur et non comme quatre (en tout cas c'est ce que j'ai compris).

En fait la solution de Médinoc fonctionne et est mieux que ce que je faisais (du coup je lis tout en une fois), d'autant que je pourrai dans le futur travailler avec des images Int par exemple et non plus float donc voulir retourner un vector de float était stupide je pense.
05/07/2013, 17h15
koala01

Salut,

Citation:

Envoyé par -Gesicht-

Parce que je manipule ensuite des images qui ont des vector<T> *data (pour les valeurs des voxels).

Et pourquoi ne pas manipuler des images qui ont des vector<T> data pour les valeurs de voxels :question:

La classe std::vector est, justement, une classe RAIIsante qui permet de représenter des tableaux de taille dynamique de manière totalement transparente pour l'utilisateur.

Cette classe est parfaitement copiable et assignable, et assure qu'il n'y aura pas de fuites mémoire lors de la destruction.

Allouer dynamiquement la mémoire pour une instance de std::vector n'a strictement aucun sens: cela t'obligerait à t'inquiéter de qui est le vrai possesseur de l'instance afin de pouvoir la détruire quand elle devient inutile, et à veiller, le cas échéant, à ce que la copie et l'affectation de la classe qui utilise cette instance se fasse correctement.

Si tu transmet une instance de std::vector sous la forme d'une référence constante dans le constructeur de la classe, que la classe manipule en interne une instance (qui sera une copie de celle passée en paramètre) de std::vector, tu n'as même plus besoin de t'inquiéter de respecter la règle des trois grands (si tu dois fournir une définition personnalisée pour une des fonctions parmi le constructeur par copie, l'opérateur d'affectation ou le destructeur, tu dois fournir une définition personnalisée pour les trois), car le constructeur par copie, l'opérateur d'affectation et le destructeur fournis par le compilateur font parfaitement leur boulot ;)