[template] ecrire dans un fichier texte le type de données, puis le relire

Bonjour à tous !

J'ai créer une classe Camera, qui commence à devenir complexe.
Pour des besoins de physique pure, j'ai dû la recoder en template afin de prendre en compte différent type de pixel possible : float, double, unsigned char, etc...

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21

template <typename T> class Camera { public: typedef typename T value_type; typedef typename vigra::BasicImage<T> image_type;   Camera(Choc &c, std::string nom_camera); virtual ~Camera(void);   image_type getImage(const float & temps_image); // Fonction principale : appel standard image_type getImage(const int & numero_image);   void genererFilm(int image_debut, int image_fin, std::string nom_fichier, boost::function<void (image_type & )> fonct); void genererFilm(float temps_debut, float temps_fin, std::string nom_fichier, boost::function<void (image_type & )> fonct);   private: // du code....   };

---

Dans la fonction genererFilm(), je génère un fichier binaire (car plus rapide) comprenant toutes les images de mon film mis bout à bout, ainsi qu'un petit fichier à côté comprenant les données du film : nombre d'images, hauteur et largeur du film...

Le problème est le suivant : Maintenant que je suis en template, comment écrire dans ce petit fichier la donnée T modèle, afin de pouvoir relire ensuite la fichier en mode binaire correctement...
Comment distinguer float et double?
Comment distinguer double et long int ? :aie:
J'avais pensé à écrire en chaine de caractère le nom, mais c'est pas très portable...

Pour info, mon ancienne fonction de lecture (unsigned short) est la suivante :

Code:

---

1 2 3 4 5 6 7 8 9 10 11

void Camera_Virtuelle::importImage(int numero_image) { std::ifstream fichier(m_nom_film.c_str(), std::ios_base::in | std::ios_base::binary);   std::vector<unsigned short> vect(m_taille_image); fichier.seekg(numero_image * m_taille_image * sizeof(unsigned short), std::ios_base::beg); fichier.read(reinterpret_cast<char*>(&vect[0]), m_taille_image * sizeof(unsigned short));   m_image = vigra::UInt16Image(m_image_width, m_image_height ,&vect[0]); }

---

qui marche très bien tant qu'on connait le format... :(

Si vous pensez à une astuce propre, je vous en serais très reconnaissant ! :D

:merci:

a part mettre une entête à ton fichier je ne vois pas

Bah oui, j'en suis là aussi pour l'instant... :?
Mais bon, je me disais peut être qu'il y avait un truc que je connaissais pas! Jusqu'à présent, on m'a toujours sortit un truc super de derrière les fagots, donc... :)

Merci quand même Mongaulois !

ou dans le nom du fichier :?

et dans un répertoire tampon?

Citation:

---

Envoyé par craryb

et dans un répertoire tampon?

---

C'est à dire?
Je veux pouvoir ouvrir mon film quelques jours plus tard dans une autre exécution.

Une fonction capable d'analyser l'en-tête pour déterminer le format de sauvegarde ?

Et si tu veux du portable, n'uilise pas int et double, des trucs plus précis comme des uint32, etc.

C'est sans doute la meilleure solution !
:merci:

tu peut aussi mettre l'entête a coté dans un fichier txt qui as le même nom par exemple

Oui, c'est la structure que j'avais déjà choisie au début de mon projet:

• Un fichier pour stocker en format texte (facilement modifiable) les attributs des images du film
• Un fichier binaire de données : les images concaténées.

Pour le problème en question, je pense définir un code:

• 0 : unsigned char (8 bits)
• 1 : uint16 (16 bits)
• 2 : uint32 (32 bits)
• 3 : double (64 bits)

J'ai pas trouvé mieux! :roll:

Argggg! Nouveau problème avec l'embryon de solution ci dessus!
Dans l'espoir de rendre le code complètement transparent pour l'utilisateur, j'aimerai encapsuler ces 0,1,2,3 dans une structure à part, ou bien une fonction membre static de ma camera virtuelle...

Se sorte qu'un appel de ce genre puisse exister :

Code:

---

Camera< lireFormat( fichier ) > camera ( /*paramètres*/ );

---

J'ai beau chercher, je ne trouve pas. Une classe de trait ne convient pas ici. Et une fonction ne peut pas renvoyer un type... :aie:

Une idée? :)

En fait, la fonction pour écrire reste assez simple, avec une classe de trait :

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

//----------------------------------------------------- // Camera Virtuelle : format // 1 -> uint 8 // 2 -> uint 16 // 3 -> uint 32 // 4 -> double //-----------------------------------------------------   template <typename T> struct Format { static const int value = 0; };   template <> struct Format <vigra::UInt8> { static const int value = 1; };   template <> struct Format <vigra::UInt16> { static const int value = 2; };   template <> struct Format <vigra::UInt32> { static const int value = 3; };   template <> struct Format <double> { static const int value = 4; };

---

Par contre, pour assigner un type depuis un numéro (fonction lire), ça va pas être pareil ! 8O
J'espère que je fonce pas dans une impasse... :aie:

Cela se fait très bien. Mets ton template sur le nombre plutôt que sur le type.
Suivant ce que tu feras, préfères définir des valeurs dans des traits via des enum qui, contrairement aux static const, sont reconnus comme expression constante.
(evidemment, à la fin, tu devras t'ecrire un switch à la main (ou l'automatiser avec un préprocesseur)...)

Après, il y a plein d'autres techniques pour définir une liste de type et déduire automatiquement le numéro d'un type et vice-versa.

Merci beaucoup pour l'aide ! :king:

Par contre, je ne m'en sors toujours pas ! :(
J'ai effectivement écrit une autre classe de "trait" (pseudo):

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

template <> struct toFormat<1> { typedef vigra::UInt8 Promote; };   template <> struct toFormat<2> { typedef vigra::UInt16 Promote; };   template <> struct toFormat<4> { typedef vigra::UInt32 Promote; };   template <> struct toFormat<8> { typedef double Promote; };

---

Ca marche dans des cas simples :

Code:

---

1 2 3 4 5

Choc choc(39800); Camera_Visible<vigra::UInt16> cam (choc, "CCD1");   Camera_Virtuelle< toFormat<2>::Promote > cam2(choc, "test"); // Ok je retombe sur UInt16

---

Mais c'est réalisé à la compilation ici, or je voudrais que la même chose soit possible à l'éxécution...

Exemple:

Code:

---

1 2 3

int numero = getSize("test"); Camera_Virtuelle< toFormat<numero>::Promote > cam2(choc, "test");

---

Le compilo hurle à la mort puisqu'il ne peut pas déterminer numero à la compilation...

Comment faire? :koi:

Merci beaucoup pour le coup de pouce qui me donnera un grand coup de main! :)

Luc parlait d'un switch, c'est ici qu'il faut l'utiliser ;)

Code:

---

1 2 3 4 5 6 7 8 9

switch (numero) { case x : { Camera_Virtuelle< toFormat<x>::Promote > cam2(choc, "test"); ... break; } }

---

Et étant donné que seul x (à remplacer par un vrai chiffre évidemment) change dans les autres cas, une macro peut aider.

Citation:

---

Envoyé par poukill

Le compilo hurle à la mort puisqu'il ne peut pas déterminer numero à la compilation...

Comment faire? :koi:

Merci beaucoup pour le coup de pouce qui me donnera un grand coup de main! :)

---

Les template sous obligatoirement évalué à la compilation :?
Une solution serait d'avoir une class virtuel parente à ta class template Camera_Virtuelle, de rajouter un GetClone() et de faire un vecteur avec des instance de chaque cas possible

en gros :

Code:

---

1 2 3 4 5 6 7 8 9

vector<Camera_Virtuelle_base *> Camera_VirtuelleFactory; Camera_VirtuelleFactory.push_back(new Camera_Virtuelle< toFormat<0>::Promote >); Camera_VirtuelleFactory.push_back(new Camera_Virtuelle< toFormat<1>::Promote >); Camera_VirtuelleFactory.push_back(new Camera_Virtuelle< toFormat<2>::Promote >); Camera_VirtuelleFactory.push_back(new Camera_Virtuelle< toFormat<3>::Promote >); . . .

---

ensuite cela ferait

Code:

---

1 2 3

int numero = getSize("test"); Camera_Virtuelle_base * cam2; cam2 =Camera_VirtuelleFactory[numero ].GetClone(choc, "test");

---

aprés il doit y avoir des pattern plus complex (comme le factory je crois). Mais le plus important, je pense , serait d'avoir une class "interface" virtuel parente

juste pour être sur

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17

switch (numero) { case 0 : Camera_Virtuelle< toFormat<0>::Promote > cam2(choc, "test"); break; case 1 : Camera_Virtuelle< toFormat<1>::Promote > cam2(choc, "test"); break; . . . default : Camera_Virtuelle< toFormat<0>::Promote > cam2(choc, "test"); break; }   cam2.quelquechose();

---

ca ne marche pas?

Si si c'est ce que j'ai fait, suite à la remarque le Laurent (que tu n'as peut être pas vu page précédente)
Ca marche parfaitement!

Donc merci à vous deux!

Par contre, je fais face à d'autres problème en ce moment, c'est que ma classe mère Camera étant maintenant en template, la compatibilité avec tout le reste du programme est compromise... J'y avais pas pensé... :aie:

Avant je pouvais facilement faire:

Code:

---

1 2 3

Camera * cam = new Camera_Fille (...); cam->getImage(20);

---

et donc manipuler toutes les Camera filles grâce à la caméra mère...

Ce qui n'est plus le cas... :cry:

Citation:

---

Envoyé par poukill

Si si c'est ce que j'ai fait, suite à la remarque le Laurent (que tu n'as peut être pas vu page précédente)
Ca marche parfaitement!

---

sisi c'est pour cela que je demande,mais j'ai pas du me faire comprendre. je réecrit le code :

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14

switch (numero) { case 0 : Camera_Virtuelle< toFormat<0>::Promote > cam2(choc, "test"); break; . . . default : Camera_Virtuelle< toFormat<0>::Promote > cam2(choc, "test"); break; }//fin du switch cam2.quelquechose();//appel hors du switch

---

Ne fonctionne pas car cam2 est déclaré dans le switch. non?

Bien sûr que ça ne marche pas! On sort du bloc de déclaration de cam2 ! :P

Effectivement, tu soulèves quand même le problème: pour récupérer la caméra en dehors du bloc c'est pas coton... Car on peut pas définir quoique ce soit en dehors su switch, ne connaissant pas le type a priori de la caméra...

Citation:

---

Envoyé par poukill

Bien sûr que ça ne marche pas! On sort du bloc de déclaration de cam2 ! :P

Effectivement, tu soulèves quand même le problème: pour récupérer la caméra en dehors du bloc c'est pas coton... Car on peut pas définir quoique ce soit en dehors su switch, ne connaissant pas le type a priori de la caméra...

---

ouf, c'était pour cela ma méthode :lol:.
En faite en premier lieux, je pense qu'il te manque une class parente pour utiliser le polymorphisme. Aprés y as plein de manière differente, a toi de voir laquel tu prefere :D

Mais j'ai déjà une classe parente (cf pièce jointe : diagramme UML avant de rajouter les template)
C'est d'ailleurs avec elle que je gérai tout par pointeur... Maintenant avec les template je peux plus...

Je vais étudier ta solution... Il faut que je pousse mon raisonnement plus loin... ;)

EDIT : ton exemple marche car ta classe mère est non virtuelle. Or j'ai plein de cas à gérer alors dans mon cas a priori il faudrait qu'elle soit virtuelle aussi...

Citation:

---

Envoyé par poukill

Mais j'ai déjà une classe parente (cf pièce jointe : diagramme UML avant de rajouter les template)
C'est d'ailleurs avec elle que je gérai tout par pointeur... Maintenant avec les template je peux plus...


EDIT : ton exemple marche car ta classe mère est non virtuelle. Or j'ai plein de cas à gérer alors dans mon cas a priori il faudrait qu'elle soit virtuelle aussi...

---

Tu pourrai ajouter une class interface (virtuel pure par exemple) entre les deux.

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

class camera { //fonction et variable commune a toute les camera }   //class intermediaire qui donne l'interface de ta class template class camera_virtuelle_interface : public camera { public : //fonction et variable commune a toute les camera virtuelle. exemple: virtual Setposition(float * p) = 0; virtual Initialisation(..) =0; virtual OpenFile(std::string fileName) =0; . . . }     template< class T> class camera_virtuelle : public camera_virtuelle_interface { //implémentation des fonctions de l'interface //plus les fonction et variable lié au type T }

---

Le plus dure est d'avoir une interface cohérente et suffisante pour être utilisé par polymorphisme,qui fait totalement abstraction du type de ta template.

Juste une question, tu fait du lancer de rayon? de la simulation? ou c'est pour interfacer des camera?

La diagramme que tu viens de voir est un gestionnaire de caméra. Effectivement, les caméras sont réelles et implantées dans un système complexe expérimental. (à part la caméra virtuelle que j'ai créer pour simuler une vraie caméra à partir d'un fichier issu d'un enregistrement d'une vraie caméra)
Mon boulot est de récupérer ces données et de faire des traitements physiques dessus. ;)

Citation:

---

Envoyé par poukill

La diagramme que tu viens de voir est un gestionnaire de caméra. Effectivement, les caméras sont réelles et implantées dans un système complexe expérimental. (à part la caméra virtuelle que j'ai créer pour simuler une vraie caméra à partir d'un fichier issu d'un enregistrement d'une vraie caméra)
Mon boulot est de récupérer ces données et de faire des traitements physiques dessus. ;)

---

Toute tes camera fournissent des image en int ou float ou char ou... et sont template ?
Dans ce cas la, peut être qu'il faudrait plutôt que tes camera ne soit pas template, mais unique la class image?
Si seul camera_virtuelle est template, cette class semble incoherente avec les autre :?

Hum... Tu me fais me poser de bonnes questions, et tu as raison.

Les caméras que je gère sont des caméras entre 10 et 14 bits... Donc la structure que j'avais initialement retenue était UInt16, évidemment.
Sauf qu'est arrivé de nouveaux besoins pour les physiciens (affichage en nombre de photons et autre), ainsi les valeurs des images après traitement atteignent 10^21... ET moi je stocke dans ma classe une image (courante) en UInt16.
Comme tu viens de le souligner, il serait effectivement bon de découpler traitement et acquisition de données... Quitte à mettre template une seule fonction membre de la classe Camera (getImage en l'occurence)

Merci pour tes questions intéressées et intéressantes mongaulois