Discussion :

[fvidal]

bonjour

alors voila, j'ai trois variables.
- enum{LUMINANCE, RGB} PixelType;
- enum{SIGNED, UNSIGNED, RATIONAL} PixelComponentType;
- unsigned int nb_bits_per_pixels;
Le type d'une image dépend de ces trois variables.

J'ai aussi ces quelques classes :
- Image<T>;
- ImageLoader<T>;
- ImageFilter1<T1, T2>;
- ImageFilter2<T1, T2>;
- ...
- ImageFilterN<T1, T2>

T, T1, et T2 correspondent au type des pixels de l'image, les valeurs possibles sont par ex. float, double, unsigned char, ..., RGBPixel<float>, ...

A savoir que le type des pixels de l'image dépends des trois variables décrites précedemment. Durant l'exécution du programme, ces variables peuvent varier du tout au tout, et fréquemment; et je dois créer des instances de Image<T>, ImageLoader<T>, et ImageFilter<T1, T2> (T1 et T2 sont différents).

Afin de simplifier le code et de permettre une meilleure maintenance de ce code, quel est la meilleur façon d'obtenir le type T à partir de trois variables lors de l'instanciation ?

J'avais commencé comme cela, en testant les variables et utilisant le préprocesseur (pour éviter de recopier tout le code à chaque fois), mais cela devient vite très très exhaustif... il faut tester toutes les valeurs possibles à chaque fois...

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
 
#define RETURN_LOADED_IMAGE(IMAGE_TYPE1) \
{ \
	ImageFileReader< Image< IMAGE_TYPE1 > >* p_file_reader(ImageFileReader< Image< IMAGE_TYPE1 > >::New()); \
	p_file_reader->SetFileName(url); \
	p_file_reader->Update(); \
	return new ItkImage< IMAGE_TYPE1 >(p_file_reader->GetOutput()); \
}
 
.....
.....
.....
	// Luminance Float
	if (aPixelType == Image::LUMINANCE && aPixelComponentType == Image::RATIONAL && bitsPerPixel->getValue() == sizeof(float) * 8)
	{
		RETURN_LOADED_IMAGE(float);
	}
	// Luminance Double
	else if (aPixelType == Image::LUMINANCE && aPixelComponentType == Image::RATIONAL && bitsPerPixel->getValue() == sizeof(double) * 8)
	{
		RETURN_LOADED_IMAGE(double);
	}
.....
.....
	// RGB Float
	else if (aPixelType == Image::RGB && aPixelComponentType == Image::RATIONAL && bitsPerPixel->getValue() == sizeof(float) * 24)
	{
		RETURN_LOADED_IMAGE(RGBPixel<float>);
	}
	// RGB Double
	else if (aPixelType == Image::RGB && aPixelComponentType == Image::RATIONAL && bitsPerPixel->getValue() == sizeof(double) * 24)
	{
		RETURN_LOADED_IMAGE(RGBPixel<double>);
	}

Des suggestions??

[Matthieu Brucher]

Arf, vive ITK.
Le principe par défaut sous-jacent, c'est le multi-dispatchig, j'ai posté une question là-dessus récemment.

[fvidal]

oui, justement, c'est pour instancier les classes d'ITK.
Cependant, il faut donner un type pour les templates d'ITK...

[Matthieu Brucher]

D'où le principe du multidispatching.

[fvidal]

Hmm, j'ai bien lu la précédente discussion sur le multi-dispatching, chercher sur google, et même de regarder l'article de Bettini et al: Double Dispatch in C++. Software - Practice and Experience. pp. 581 - 613:32(6). 2006. Cependant, je ne trouve pas de cas concrêt similaire à mon problème.

Je vois bien le principe du multi-dispatching ; mais je ne vois pas trop comment m'en sortir avec ces infos pour une utilisation avec des templates, c.-à-d. comment créer les instances de classes du bon type en fonction de 3 variables sans que ça devienne exaustif.

En gros ce que j'ai en ce moment est:

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
 
switch(i)
{
case 1:
   {
      ImageLoader<float>.... fait_quelque_chose ....;
      return new Image<float>;
   }
case 2:
   {
      ImageLoader<double>.... fait_quelque_chose ....;
      return new Image<double>;
   }
case 3:
   ...
case 4:
   ...
case 5:
   ...
}

En plus de cela il faut que je fasse la même chose pour différent ItkLoader, sans parler des filtres dont la liste de types est multiple...

Y a pas un exemple quelque part?

[Matthieu Brucher]

T'as pas cherché très longtemps sur le forum, toi...
http://www.developpez.net/forums/sho...ti-dispatching

La méthode de Bettini est inutile car le C++ possède déjà les mécanismes adéquats pour le multi-dispatching.

[fvidal]

comme écrit précédemment, j'ai bien lu ce sujet relatif au multi-dispatching.
Cependant, j'ai peut-être raté un truc, mais je ne vois pas comment m'en sortir avec ces infos...

[Matthieu Brucher]

L'exemple que j'ai donné - qui doit être modifié pour compiler car utilisant des spécialisation de fonctions template - permet à partir d'une liste de types pour lesquels instancier l'algorithme de générer un test permettant de lancer le bon algorithme.

Il suffit de modifier la fonction de comparaison qui compare actuellement le nom de l'objet à l'aide d'une fonction virtuelle type() à un traits qui donne le nom du type en cours de test pour l'adapter à ce qu'ITK propose.