Discussion :

[poukill]

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 :

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

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 ?
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 :

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

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 !

[yan]

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

[poukill]

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 !

[yan]

ou dans le nom du fichier

[craryb]

et dans un répertoire tampon?

[poukill]

et dans un répertoire tampon?

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

[Luc Hermitte]

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.

[poukill]

C'est sans doute la meilleure solution !

[yan]

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

[poukill]

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!

[poukill]

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 :

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

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...

Une idée?

[poukill]

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

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
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 !
J'espère que je fonce pas dans une impasse...

[Luc Hermitte]

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.

[poukill]

Merci beaucoup pour l'aide !

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

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
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 :

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

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 :

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

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?

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

[Laurent Gomila]

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

Code :

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

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.

[yan]

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

Comment faire?

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 C++ :

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

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 C++ :

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

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

[yan]

juste pour être sur

Code C++ :

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

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?

[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!

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é...

Avant je pouvais facilement faire:

Code :

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

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...

[yan]

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 C++ :

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

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?

[poukill]

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

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...