Discussion :

[dambriscard]

Bonjour,
Le titre est flou, je vais essayer de l’exposer, tout d’abord je programme en C++, ce qui justifie la place de ce post bien que cela soit un problème de conception.

Dans le cadre d'un projet de fin d'études, je dois analyser des séquences d'images vidéo. Vu qu'il y'a une cascade de traitements une implémentation en classes s'impose.

Ca devient très vite compliqué du fait qu’il y'a des indicateurs statistiques qui doivent être pré calculer, en plus de flags pouvant influer sur une décision algorithmique ultérieure. De plus ces flags doivent pouvoir être changés au cours des chaines de traitements. Par exemple : Si rejet de l’image= TRUE alors stoppe le processus de calcul et détruit l´image.
Mais voila le truc c'est que pour chaque image d'entrée ou je calcule ces indicateurs (histogramme, variance…), il me faut ces données (calculées une fois pour toutes) et disponibles pour d’autres classes le temps de l’image mais évidemment sans que ces autres classes ne les recalculent. Ces classes pouvant seulement changer le statut de certains Flags.

Pour préciser plus, j’ai mon main (un GUI + tard) qui ne fait que de recevoir les images et qui envoie ladite l’image plus quelques indications vers une « classe centrale » qui va pré analyser cette image avec la classe « pré analyse de l’image » et instancier d’autres classes de traitement qui auront besoin des attributs de la classe « pré analyse de l’image ».
Pour l’instant, il y’a une relation d’amitié entre ma « classe centrale » et ma classe « pré analyse de l’image » mais par exemple la « classe segmentation » n’a pas instanciée d’objet de la classe « pré analyse de l’image » et ne peut pas lire les données. D’ailleurs cette classe a par exemple besoin de 2 données parmi 20 présentes et agit sur un flag.
Alors comment les rendre disponibles sans que la classe centrale ne doive envoyer a droite a gauche des bouts de données ou carrément la structure complète comportant ces données. D’ailleurs c’est la première solution que j’ai retenu et ça fait vite usine à gaz et pire encore si la liste et le type des attributs s'allongent.
Je préférai aussi éviter que la classe centrale soit amie avec tout le monde et que seulement la classe « pré analyse de l’image » le soit et donc que cette classe existe et reste instanciée par la classe centrale.

Je me rends bien compte que c’est un problème de débutant mais ca fait déjà toute la journée que je me casse les dents dessus. D’ailleurs je dois dire qu’en relisant ca a l’air pas clair et que je resterai longtemps encore débutant devant l’éternel de la programmation.
Je suis prêt à recevoir toute aide ou suggestion, je préférerai quand même garder une structure en classe pour des raisons de clartés et de transmission de projet.
Merci de votre aide.
Damien

[3DArchi]

D’ailleurs je dois dire qu’en relisant ca a l’air pas clair

Je te le confirme, c'est pas très clair
Conseil: fait ta conception, sort un joli diagramme de classe et poste-le côté conception. Ce n'est pas un problème C++ même si au final tu choisis ce langage.
Regarde du côté des design pattern (fais une recherche dans le site, il y a beaucoup de ressources là dessus).

[dambriscard]

Merci pour ta réponse si rapide mais le prend pas mal si je te contredis . Je vais meme persister dans ma question quitte a recevoir une cabale en retour

Bon, faisons alors un exemple pour expliquer mon cas, j'aurai du faire cela tout de suite et laisser tomber le blabla. Je l'ai écris a la volée sans le tester mais plutôt pour donner l'idée générale.
Pour la petite histoire, le projet initial ayant gagné en ambition c'est bien en refaisant mon diagramme de classe UML ce matin que j'ai décidé de faire comme cela, j'y gagne en clarté pour d'éventuels repreneurs mais aussi ça me facilitera grandement les choses pour la suite. Alors voila l'exemple. Ici je choisis comme solution une classe mais je suis preneur d'autres idées qui permettraient de faire ce que je voudrais faire.

le main

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
 
 
# include "ClassA.h" etc...
 
int main() 
{ 
 
 ClassA *MaClasseA = new ClassA;
 MaClasseA->unechainedetraitement(monimagepath);
 
 delete MaClasseA;
 
 
 return 0;
 }

ma classe A

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
 
class ClassA
{
 private:
 typeimage monimage;
 ClassB *MaClasseB;
 ClassC *MaClasseC;
 
 public:
  ClassA(void) ;
 ~ClassA(void); 
 
 void unechainedetraitement(type monimagepath);
 
};
 
 ClassA::ClassA(void)
    {
 
    MaClasseB = new ClassB;
    MaClasseC = new ClassC;
 
     }
 
 void ClassA::unechainedetraitement(type monimagepath);
 {
 
	 monimage=chargeimage(monimagepath); 
	 MaClasseB->CalculparamImg(monimage);
	 printf("ma val1: %d",MaClasseB->val1); 
      //comm il y'a une amitie  entre B et A je peux le faire
 
	 ClassC->SegemtationImg(monimage);
 
 }

maclasseB

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
 
class ClassB
{
 friend class ClassA;
 
 private:
 int val1;
 int val2;
 int *histo;
 bool flagB;
 
 public:
  ClassB(void) ; {} //init de mes vals a 0 etc...
 ~ClassB(void);
 
  void CalculparamImg(typeimage monimage);
 
};
 
 
 void ClassB::CalculparamImg(typeimage monimage)
     {
    val1= sommepixels(monimage);
	histo= histogramcalcul(monimage);
	//etc...
     }

la classe C ou quelque chose d'équivalent

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
 
 class ClassC
{ 
 
 private:
  bool monflag;
 
 public:
  ClassC(void) ; {} //init de mes vals a 0
 ~Classc(void);
 
  void SegemtationImg(typeimage monimage)
  void Algo1(); 
  void Algo2();
 
};
 
 
 void ClassC::SegemtationImg(typeimage monimage);
     {
    monflag= flagB;  //C la le problème comment lire ce flagB sans instancier la classe B 
	if (monflag==TRUE) Algo1();
	else Algo2();
	//etc...
     }

Allez j'en remets une tartine
L'idée de la dernière classe c'est une sorte de look up table un peu évoluée ou chaque classe la lirait mais sans la recevoir en argument et pourrait changer bien sur agir sur les flags.

j'ai quand même du mal a croire qu'en C++, on peut pas faire quelque chose comme cela, n'étant pas un spécialiste du tout, je me tourne alors vers vous.


voila en espérant une solution
Cordialement
Damien

[LittleWhite]

Euh , j'ai un peu de mal à suivre ... mais je pense que dans la façon que tu le dis , le raisonnement me semble pas ultra parfait ... enfin je dis ça , j'ai peut être rien compris ...

Pour résumer , ce que je voulais dire , c'est qu'il faut peut être prendre le raisonnement autrement.

Tu construit une classe Image.
Avec celle ci , tu passe dans le constructeur , le chemin de l'image..; tu prépare tes données ( genre un tableau avec tous les pixels de l'image ... enfin je sais pas ce que tu veux précisément )
Et tu fais un destructeur de la classe Image , propre , qui désalloue toute la mémoire.

Dans cette classe tu as une fonction "faireAlgoDeTraitement"
Dans celle ci tu vas appelée les algo de traitement, que tu aura fais en héritage ( j'explique après )

Dans ta classe Image , tu as tous les flags , et autre valeurs dont tu as besoin.
à chaque fois que tu apelle un algo , tu vas lui passer des références sur les flags qui a le droit de modifier , et ceux qui ne vont seulement être lu tu peux passer normalement ( sans pointeurs ).


Héritage :

Tu crée une class Traitement,

qui à une méthode "algo" en virtuelle pure ( donc elle se retrouvera dans toute les class fille ) et d'autre truc que tu aura besoin , genre getFlags ... qui n'a pas besoin d'être virtuel ni pure. Et qui ne change pas selon le traitement.

( Pure = pas de corps , virtuel = surchargée dans la class fille )

Après pour chaque traitement , tu fais l'héritage
soit :

Code :

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

1
2
3
4
5
 
class NouveauTraitement:public Traitement
{
 
};

Et pour chaque nouvelle class , tu vas redéfinir le code ... contenu dans la fonction algo.

( Par contre algo , devra avoir tout le temps les mêmes types de paramètres ... ce qui peut poser problème et que j'avais oublier dans ma réfléxion. Mais tu peut dejouer ça , en faisant des structures ou des tableaux )
Enfin je voulais essayer de proposer une autre façon de voir la chose ... pour te débloquer ... mais moi même je me retrouve bloquer devant ton problême...

[3DArchi]

Merci pour ta réponse si rapide mais le prend pas mal si je te contredis . Je vais meme persister dans ma question quitte a recevoir une cabale en retour

Je ne le prend pas mal, rassures-toi
Mais, l'expérience montre que si tu as déjà du mal à préciser ton problème, c'est qu'à la base, tu as du avoir du mal à le concevoir. D'où mon conseil de recommencer par là....

Code :

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

1
2
3
4
5
6
7
8
 
 ClassA::ClassA(void)
    {
 
    MaClasseB = new ClassB;
    MaClasseC = new ClassC;
 
     }

Ta gestion des pointeurs présente de gros risques.

Code :

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

1
2
 
	 printf("ma val1: %d",MaClasseB->val1);

Tu n'as pas forcément besoin de passer par une amitié. Tu peux aussi créer un accesseur dans B pour récupérer la valeur.

Code :

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

1
2
3
4
5
6
7
8
 
 void ClassC::SegemtationImg(typeimage monimage);
     {
    monflag= flagB;  //C la le problème comment lire ce flagB sans instancier la classe B 
	if (monflag==TRUE) Algo1();
	else Algo2();
	//etc...
     }

Là, j'ai du mal à te suivre. Cette méthode est invoquée par A qui a une instance de B. Pourquoi ne pas mettre le flag en paramètre et le fournir par A lors de son appel avec la valeur de son instance de B?

Allez j'en remets une tartine
L'idée de la dernière classe c'est une sorte de look up table un peu évoluée ou chaque classe la lirait mais sans la recevoir en argument et pourrait changer bien sur agir sur les flags.

J'avoue que je ne comprend pas ce que tu veux dire
Cependant, je soupçonne que l'utilisation de politiques pourrait t'aider. Mais, je n'en suis pas sûr. Lit donc cet article et peut-être cela t'ouvrira des perspectives.

[dambriscard]

ok merci pour les réponses,

je dois malheureusement remettre a plus tard cette discussion. C'est vrai j'ai écrit le code exemple a l'arrache, c'était plus pour l'idée gal que pour la rigueur. je reprendrai vos points, lirai les liens etc.. et comme on dit
j'utiliserai le droit de réponse du néophyte.

Mon principal souci pour l'instant que je dois présenter mon travail de 3 mois mardi qui vient (en allemand ) et c'est le traitement d'image et le prototype d'acquisition d'image construit que j'aimerai mettre en avant pour l'instant.

Je vous accorde que la nouvelle conception n'a pas l'air terrible, en fait avant hier, je n'avais pas ce problème car je dirai que j'avais une approche très scolaire, très UML finalement. Ce qui m'embête c'est que c'est plein d'accesseurs partout, de passage de paramètres a ne plus en finir et je perds en lisibilité, en clarté. Même envoyer des structures complètes, je suis moyen bouillant

L'idée finalement est que je ne veux qu'envoyer et recevoir des images en paramètres entre les classes, pas d'autres paramètres ou extrêmement peu.

Je cherche donc une autre approche quitte a un peu sacrifier ce qui fait la force de la conception objet pour une partie de mon code.
La je dois avoir pas loin de 3000 lignes de codes non optimisés, une quarantaine d'algos plus ou moins compliqués(je vais en écrire encore plus) et j'aimerai faire agir de façon plus dynamique et plus interactive en général.

Pour revenir à cette idée de LUT (appelons la comme cela pour le moment, j'ai pas de nom qui me vient). Cette LUT est calculées a la réception de l'image, c la première opération que je fait d'ailleurs.

Alors chaque image traitée possède une base de données propres composées d'histo, de différentes valeurs statistiques, de plusieurs flags et surtout les résultats calculés par les différents algos.

Chaque classe ou plutôt chaque objet instancié:
- a le droit de les lire pour par exemple choisir l'algo optimum en fonction des indicateurs stats.
- Peut a partir de ces données fixer des paramètres pour l'algo choisi
certains algos demande des paramètres d'entrees etc...

- de modifier certains flags, dont le flag arrête le traitement en cours , jette l'image et appelle une nouvelle image
- voir a le droit de recalculer une partie de ces valeurs en appelant les fct adéquates de la LUT.

En gros ça devrait se comporter un peu comme une variable globale mais la c'est carrément plus.
on peut voir cela aussi comme cela la LUT c'est l'amie de toutes les classes
même ceux qui n'ont pas de liens de parenté entre eux.

Quand la multitude de traitement est fini, j'aimerai pouvoir sauvegarder une partie de cette base de données plus l'image de départ.

voila en espérant avoir été plus clair, sur papier et dans ma tête c'est clair et malheureusement impossible à coder pour l'instant.
Je me dis quand même pour consolation que c'est possible en C++ mais que je ne connais pas la solution mais vous si.

Merci de votre temps
Damien

[3DArchi]

Encore une piste: le pattern visiteur?

[dambriscard]

ok merci
je lirai cela, a première vue en lisant de travers ça a l'air d'être assez schiadee comme concept. Je suis pas sur que j'ai le niveau pour l'adapter a mon code mais l'idée me séduit.
Bien sur je prends toujours avec plaisir d'autres suggestions.

a+
D