Discussion :

[drunkskater]

Bonjour,

Je profite des vacances pour reprendre un "vieux projet" de simulation de milieu de culture de cellules.

Mon programme est *presque* fini : reste à régler quelques problèmes et à nettoyer un peu le code mais globalement ça devrait aller.

En revanche, voici le type de mes objets :

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
type compose = 
  { nom : string;
    vital : bool;
    lim : (float * float);
    prel : float;
    conso : float;
    mutable res : float }
;;
 
type cellule = 
  { ind : int;
    coul : int;
    mut : int;
    mob : (int * (float array));
    moved : bool;
    mit : (int * ((float * float) array)) ;
    comp : compose array }
;;

Du coup le problème c'est que pour lancer une simulation dans un milieu comportant initialement 5 types de cellules et prenant en compte l'influence de 6 composés, ça fait 30 composés (* au plus *) et 5 cellules à taper à la main - sans compter la liste associative qui à un indice associe la cellule correspondante...

Je voudrais donc faire une interface graphique (toute simple) pour faciliter tout ça. J'ai décidé de tenter le coup en LablGTK parce que j'ai l'impression que ça permet de faire des choses plus jolies que CamlTk...

Le problème c'est que je n'ai aucune idée de comment m'y prendre. Je voudrais donc savoir si vous auriez un peu de doc que je pourrais potasser avant de tenter un truc et de revenir ici en courant au premier problème "insurmontable" rencontré. J'ai déjà lu les billets sur LablGTK du le blog de Cacophrène (qui sont super d'ailleurs !), mais mon cas est désespéré et je pense qu'il me faudrait peut-être un cours de GTK grand débutant...

Concrètement, je voudrais qu'au démarrage du programme une fenêtre s'ouvre et propose deux options : 'charger une simulation' ou 'nouvelle simulation'. 'Nouvelle simulation' ouvrirait ensuite une fenêtre comportant divers champs à remplir pour créer les cellules. Une fois tout rempli, on peut choisir d'enregistrer la simulation et/ou de la lancer.

Seulement je ne sais pas trop quel type de structure de données utiliser pour stocker les informations au cours de la construction. J'ai lu le passage du manuel d'Ocaml sur le marshaling mais c'est pas très détaillé pour un débutant...

Bref, pour l'instant j'ai surtout besoin de conseils sur la direction à prendre. Ensuite, je galèrerait pour faire en sorte que ça marche...

Merci d'avance !

[gasche]

Honnêtement, l'idée de l'interface graphique pour simplifier l'entrée des données... je n'y crois pas du tout. Fais toi un bon parseur texte de fichiers de configuration, tu pourras facilement réutiliser tes fichiers d'entrée d'une fois sur l'autre (alors qu'avec une interface...), et ce sera certainement beaucoup plus productif sur le long terme.

Ou alors je n'ai pas compris ce que tu veux faire.

[drunkskater]

Qu'entends-tu par parseur ?


En fait je fais un petit programme pour moi, donc je n'ai aucune contrainte et je ne sais pas trop quelle solution adopter (-> et je suis preneur de toute suggestion et prêt à tout remodifier !)

De plus ce programme n'est pas un truc sérieux, je fais juste ça pour m'amuser donc il n'y a pas vraiment de question de productivité sur le long terme. C'est autant pour faire le programme que pour l'utiliser que je le fais.


Pour l'instant quand je veux utiliser le programme je dois faire ça :

J'ai le programme presque fini dans un fichier .ml. Quand je veux l'utiliser, je le charge dans l'interpréteur.

Ensuite, je dois charger un certain nombre de cellules. Par exemple, si je veux faire une simulation avec deux types de cellules et deux composés, je dois taper :

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
39
40
41
42
43
44
45
46
(* Ici, deux composés seulement pour deux cellules car les cellules ont les  *)
(* mêmes besoin en nutriments et ne diffèrent que par leur mobilité et leur  *)
(* taux de mutation                                                          *)
 
let c1 = 
  { vital = true;
    nom = "c1";
    lim = (0., 10.);
    prel = 1.5;
    conso = 1.;
    res = 1. }
;;
 
let c2 = 
  { vital = false;
    nom = "c2";
    lim = (0., 15.);
    prel = -1.;
    conso = -1.1;
    res = 10. }
;;
 
let cell1 = 
  { ind = 1;
    coul = green;
    mut = 20;
    mob = (0, [|0.; 0.|]);
    moved = false;
    mit = (50, [|(3., 10.); (0.5,15.)|]);
    comp = [|c1; c2|] }
;;
 
let cell2 = 
  { ind = 2;
    coul = blue;
    mut = 2;
    mob = (1, [|2.; -1.|]);
    moved = false;
    mit = (50, [|(3., 10.); (0.5,15.)|]);
    comp = [|c1; c2|] }
;;
 
(* Liste associative qui sera utilisée pour la construction du milieu de     *)
(* culture                                                                   *)
 
cellules := (2, cell2) :: (1, cell1) :: !cellules ;;

Ensuite, il faut placer les cellules dans le milieu de culture. Par exemple, si je veux que le milieu de culture soit une matrice 30 * 30, je tape :

Code :

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

let milieu = fab_mat 30 30 ;;

Une fenêtre de CamlGraph s'ouvre, et je place les cellules en cliquant aux endroit désirés. Quand j'ai fini j'appuie sur échap et mon milieu de culture est défini. Par exemple :



Et enfin quand je veux lancer la simulation il faut taper :

Code :

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

1
2
3
(* Exemples de concentration du milieu extérieurs en nutriments *)
 
jeu milieu [|0.7; 0.1|] ;;

Ensuite, tout se déroule comme souhaité et les cellules se développent



Et on observe des trucs "rigolos" qui servent à rien. Par exemple que les cellules mobiles finissent toujours, pour une consommation de nutriments identiques, par l'emporter :



Je concède que c'est pas vraiment utile comme programme mais c'est les vacances et j'ai un peu de temps à tuer


Mais ça fait quand même un paquet de trucs à taper pour lancer une malheureuse simulation avec deux cellules quasi-identiques et ne prenant en compte que deux nutriments. (Et c'est pas très intuitif pour quelqu'un qui n'a jamais fait de Caml)

Du coup, je voudrais compiler un programme indépendant que je puisse lancer comme n'importe quel autre programme, et que je puisse ensuite utiliser simplement.

Par exemple un menu offrant deux options : 'lancer une simulation enregistrée' ou 'créer une nouvelle simulation' (de multiples fenêtres permettraient alors de définir chaque cellules puis de les placer dans le milieu de culture)

Je vois bien un espèce de truc "pas à pas" : on commence par définir la taille du milieu, le nombre de nutriments différents, leurs concentrations de base respectives, puis on valide. On doit ensuite définir chaque cellule une par une en remplissant divers champs. Une fois ceci fait, on valide puis on place les cellules. On enregistre, et on lance la simulation.

Le problème c'est que je n'ai aucune idée de la difficulté de la tâche, c'est pour ça que je demande des conseils

[drunkskater]

Pour résumer, mon objectif est de faire un "vrai" programme utilisable du premier coup par quelqu'un n'ayant jamais fait de Caml.

L'interface graphique n'est peut-être pas la meilleure idée (et en plus ça m'ennuie un peu de passer du temps dessus) mais en même temps je n'en ai jamais fait, je n'ai aucune idée de comment ça marche et ça m'intrigue...